diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 4809a830..78803e8a 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -133,6 +133,13 @@
       <option name="FOR_BRACE_FORCE" value="3" />
       <option name="PARENT_SETTINGS_INSTALLED" value="true" />
     </codeStyleSettings>
+    <codeStyleSettings language="Groovy">
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+        <option name="TAB_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
     <codeStyleSettings language="HTML">
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
@@ -147,8 +154,10 @@
       <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
       <option name="ALIGN_MULTILINE_RESOURCES" value="false" />
       <option name="ALIGN_MULTILINE_FOR" value="false" />
-      <option name="CALL_PARAMETERS_WRAP" value="1" />
-      <option name="METHOD_PARAMETERS_WRAP" value="1" />
+      <option name="CALL_PARAMETERS_WRAP" value="5" />
+      <option name="CALL_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
+      <option name="METHOD_PARAMETERS_WRAP" value="5" />
+      <option name="METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
       <option name="EXTENDS_LIST_WRAP" value="1" />
       <option name="THROWS_KEYWORD_WRAP" value="1" />
       <option name="METHOD_CALL_CHAIN_WRAP" value="1" />
diff --git a/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLHttpServlet.java b/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLHttpServlet.java
index 2e52b98e..f9fdae46 100644
--- a/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLHttpServlet.java
+++ b/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLHttpServlet.java
@@ -8,11 +8,6 @@
 import graphql.kickstart.servlet.core.GraphQLMBean;
 import graphql.kickstart.servlet.core.GraphQLServletListener;
 import graphql.schema.GraphQLFieldDefinition;
-import java.util.List;
-import java.util.Objects;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.stream.Collectors;
 import javax.servlet.Servlet;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
@@ -85,43 +80,10 @@ protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
   }
 
   private void doRequest(HttpServletRequest request, HttpServletResponse response) {
-    List<GraphQLServletListener.RequestCallback> requestCallbacks =
-        runListeners(l -> l.onRequest(request, response));
-
     try {
       getConfiguration().getHttpRequestHandler().handle(request, response);
-      runCallbacks(requestCallbacks, c -> c.onSuccess(request, response));
     } catch (Exception t) {
       log.error("Error executing GraphQL request!", t);
-      runCallbacks(requestCallbacks, c -> c.onError(request, response, t));
-    } finally {
-      runCallbacks(requestCallbacks, c -> c.onFinally(request, response));
     }
   }
-
-  private <R> List<R> runListeners(Function<? super GraphQLServletListener, R> action) {
-    return getConfiguration().getListeners().stream()
-        .map(
-            listener -> {
-              try {
-                return action.apply(listener);
-              } catch (Exception t) {
-                log.error("Error running listener: {}", listener, t);
-                return null;
-              }
-            })
-        .filter(Objects::nonNull)
-        .collect(Collectors.toList());
-  }
-
-  private <T> void runCallbacks(List<T> callbacks, Consumer<T> action) {
-    callbacks.forEach(
-        callback -> {
-          try {
-            action.accept(callback);
-          } catch (Exception t) {
-            log.error("Error running callback: {}", callback, t);
-          }
-        });
-  }
 }
diff --git a/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestInvokerImpl.java b/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestInvokerImpl.java
index c0f52688..cc1b39ec 100644
--- a/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestInvokerImpl.java
+++ b/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestInvokerImpl.java
@@ -37,28 +37,37 @@ public void execute(
               ? request.getAsyncContext()
               : request.startAsync(request, response);
       asyncContext.setTimeout(configuration.getAsyncTimeout());
-      invoke(invocationInput, request, response)
-          .thenAccept(result -> writeResultResponse(invocationInput, result, request, response))
-          .exceptionally(t -> writeErrorResponse(t, response))
+      invokeAndHandle(invocationInput, request, response)
           .thenAccept(aVoid -> asyncContext.complete());
     } else {
-      try {
-        GraphQLQueryResult result = invoke(invocationInput, request, response).join();
-        writeResultResponse(invocationInput, result, request, response);
-      } catch (Exception t) {
-        writeErrorResponse(t, response);
-      }
+      invokeAndHandle(invocationInput, request, response).join();
     }
   }
 
+  private CompletableFuture<Void> invokeAndHandle(
+      GraphQLInvocationInput invocationInput,
+      HttpServletRequest request,
+      HttpServletResponse response) {
+    ListenerHandler listenerHandler =
+        ListenerHandler.start(request, response, configuration.getListeners());
+    return invoke(invocationInput, request, response)
+        .thenAccept(
+            result ->
+                writeResultResponse(invocationInput, result, request, response, listenerHandler))
+        .exceptionally(t -> writeErrorResponse(t, response, listenerHandler))
+        .thenAccept(aVoid -> listenerHandler.onFinally());
+  }
+
   private void writeResultResponse(
       GraphQLInvocationInput invocationInput,
       GraphQLQueryResult queryResult,
       HttpServletRequest request,
-      HttpServletResponse response) {
+      HttpServletResponse response,
+      ListenerHandler listenerHandler) {
     QueryResponseWriter queryResponseWriter = createWriter(invocationInput, queryResult);
     try {
       queryResponseWriter.write(request, response);
+      listenerHandler.onSuccess();
     } catch (IOException e) {
       throw new UncheckedIOException(e);
     }
@@ -69,10 +78,12 @@ protected QueryResponseWriter createWriter(
     return queryResponseWriterFactory.createWriter(invocationInput, queryResult, configuration);
   }
 
-  private Void writeErrorResponse(Throwable t, HttpServletResponse response) {
+  private Void writeErrorResponse(
+      Throwable t, HttpServletResponse response, ListenerHandler listenerHandler) {
     response.setStatus(STATUS_BAD_REQUEST);
     log.info(
         "Bad request: path was not \"/schema.json\" or no query variable named \"query\" given", t);
+    listenerHandler.onError(t);
     return null;
   }
 
diff --git a/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ListenerHandler.java b/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ListenerHandler.java
new file mode 100644
index 00000000..d9461002
--- /dev/null
+++ b/graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ListenerHandler.java
@@ -0,0 +1,74 @@
+package graphql.kickstart.servlet;
+
+import static java.util.Collections.emptyList;
+
+import graphql.kickstart.servlet.core.GraphQLServletListener;
+import graphql.kickstart.servlet.core.GraphQLServletListener.RequestCallback;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor
+class ListenerHandler {
+
+  private final List<RequestCallback> callbacks;
+  private final HttpServletRequest request;
+  private final HttpServletResponse response;
+
+  static ListenerHandler start(
+      HttpServletRequest request,
+      HttpServletResponse response,
+      List<GraphQLServletListener> listeners) {
+    if (listeners != null) {
+      return new ListenerHandler(
+          runListeners(listeners, it -> it.onRequest(request, response)), request, response);
+    }
+    return new ListenerHandler(emptyList(), request, response);
+  }
+
+  private static <R> List<R> runListeners(
+      List<GraphQLServletListener> listeners, Function<? super GraphQLServletListener, R> action) {
+    return listeners.stream()
+        .map(
+            listener -> {
+              try {
+                return action.apply(listener);
+              } catch (Exception t) {
+                log.error("Error running listener: {}", listener, t);
+                return null;
+              }
+            })
+        .filter(Objects::nonNull)
+        .collect(Collectors.toList());
+  }
+
+  void runCallbacks(Consumer<RequestCallback> action) {
+    callbacks.forEach(
+        callback -> {
+          try {
+            action.accept(callback);
+          } catch (Exception t) {
+            log.error("Error running callback: {}", callback, t);
+          }
+        });
+  }
+
+  void onSuccess() {
+    runCallbacks(it -> it.onSuccess(request, response));
+  }
+
+  void onError(Throwable throwable) {
+    runCallbacks(it -> it.onError(request, response, throwable));
+  }
+
+  void onFinally() {
+    runCallbacks(it -> it.onFinally(request, response));
+  }
+}
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/AbstractGraphQLHttpServletSpec.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/AbstractGraphQLHttpServletSpec.groovy
index 36430285..0eb86ef9 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/AbstractGraphQLHttpServletSpec.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/AbstractGraphQLHttpServletSpec.groovy
@@ -23,1173 +23,1173 @@ import java.util.concurrent.atomic.AtomicReference
  */
 class AbstractGraphQLHttpServletSpec extends Specification {
 
-    public static final int STATUS_OK = 200
-    public static final int STATUS_BAD_REQUEST = 400
-    public static final int STATUS_ERROR = 500
-    public static final String CONTENT_TYPE_JSON_UTF8 = 'application/json;charset=UTF-8'
-    public static final String CONTENT_TYPE_SERVER_SENT_EVENTS = 'text/event-stream;charset=UTF-8'
-
-    @Shared
-    ObjectMapper mapper = new ObjectMapper()
-
-    AbstractGraphQLHttpServlet servlet
-    MockHttpServletRequest request
-    MockHttpServletResponse response
-    CountDownLatch subscriptionLatch
-
-    def setup() {
-        subscriptionLatch = new CountDownLatch(1)
-        servlet = TestUtils.createDefaultServlet({ env -> env.arguments.arg }, { env -> env.arguments.arg }, { env ->
-            AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
-            publisherRef.set(new SingleSubscriberPublisher<String>({
-                SingleSubscriberPublisher<String> publisher = publisherRef.get()
-                publisher.offer("First\n\n" + env.arguments.arg)
-                publisher.offer("Second\n\n" + env.arguments.arg)
-                publisher.noMoreData()
-                subscriptionLatch.countDown()
-            }))
-            return publisherRef.get()
-        })
-
-        request = new MockHttpServletRequest()
-        request.setAsyncSupported(true)
-        request.asyncSupported = true
-        request.setMethod("GET")
-        response = new MockHttpServletResponse()
-    }
-
-
-    Map<String, Object> getResponseContent() {
-        mapper.readValue(response.getContentAsByteArray(), Map)
-    }
-
-    List<Map<String, Object>> getSubscriptionResponseContent() {
-        String[] data = response.getContentAsString().split("\n\n")
-        return data.collect { dataLine ->
-            if (dataLine.startsWith("data: ")) {
-                return mapper.readValue(dataLine.substring(5), Map)
-            } else {
-                throw new IllegalStateException("Could not read event stream")
-            }
-        }
-    }
-
-    List<Map<String, Object>> getBatchedResponseContent() {
-        mapper.readValue(response.getContentAsByteArray(), List)
-    }
-
-    def "HTTP GET without info returns bad request"() {
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_BAD_REQUEST
-    }
-
-    def "HTTP GET to /schema.json returns introspection query"() {
-        setup:
-        request.setPathInfo('/schema.json')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.__schema != null
-    }
-
-    def "query over HTTP GET returns data"() {
-        setup:
-        request.addParameter('query', 'query { echo(arg:"test") }')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        response.getContentLength() == mapper.writeValueAsString(["data": ["echo": "test"]]).getBytes(StandardCharsets.UTF_8).length
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP GET returns data with correct contentLength"() {
-        setup:
-        request.addParameter('query', 'query { echo(arg:"special char á") }')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        response.getContentLength() == mapper.writeValueAsString(["data": ["echo": "special char á"]]).getBytes(StandardCharsets.UTF_8).length
-        getResponseContent().data.echo == "special char á"
-    }
-
-    def "disabling async support on request over HTTP GET does not start async request"() {
-        setup:
-        servlet = TestUtils.createDefaultServlet({ env -> env.arguments.arg }, { env -> env.arguments.arg }, { env ->
-            AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>();
-            publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
-                publisherRef.get().offer(env.arguments.arg)
-                publisherRef.get().noMoreData()
-            }))
-            return publisherRef.get()
-        })
-        request.addParameter('query', 'query { echo(arg:"test") }')
-        request.setAsyncSupported(false)
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        request.asyncContext == null
-    }
-
-    def "query over HTTP GET with variables returns data"() {
-        setup:
-        request.addParameter('query', 'query Echo($arg: String) { echo(arg:$arg) }')
-        request.addParameter('variables', '{"arg": "test"}')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP GET with variables as string returns data"() {
-        setup:
-        request.addParameter('query', 'query Echo($arg: String) { echo(arg:$arg) }')
-        request.addParameter('variables', '"{\\"arg\\": \\"test\\"}"')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP GET with operationName returns data"() {
-        when:
-        response = new MockHttpServletResponse()
-        request.addParameter('query', 'query one{ echoOne: echo(arg:"test-one") } query two{ echoTwo: echo(arg:"test-two") }')
-        request.addParameter('operationName', 'two')
-        servlet.doGet(request, response)
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echoOne == null
-        getResponseContent().data.echoTwo == "test-two"
-
-    }
-
-    def "query over HTTP GET with empty non-null operationName returns data"() {
-        when:
-        response = new MockHttpServletResponse()
-        request.addParameter('query', 'query echo{ echo: echo(arg:"test") }')
-        request.addParameter('operationName', '')
-        servlet.doGet(request, response)
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP GET with unknown property 'test' returns data"() {
-        setup:
-        request.addParameter('query', 'query { echo(arg:"test") }')
-        request.addParameter('test', 'test')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "batched query over HTTP GET returns data"() {
-        setup:
-        request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP GET returns data with correct contentLength"() {
-        setup:
-        request.addParameter('query', '[{ "query": "query { echo(arg:\\"special char á\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        response.getContentLength() == mapper.writeValueAsString([["data": ["echo": "special char á"]], ["data": ["echo": "test"]]]).getBytes(StandardCharsets.UTF_8).length
-        getBatchedResponseContent()[0].data.echo == "special char á"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP GET with variables returns data"() {
-        setup:
-        request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }", "variables": { "arg": "test" } }, { "query": "query { echo(arg:\\"test\\") }", "variables": { "arg": "test" } }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP GET with variables as string returns data"() {
-        setup:
-        request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }", "variables": "{ \\"arg\\": \\"test\\" }" }, { "query": "query { echo(arg:\\"test\\") }", "variables": "{ \\"arg\\": \\"test\\" }" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP GET with operationName returns data"() {
-        when:
-        response = new MockHttpServletResponse()
-        request.addParameter('query', '[{ "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "one" }, { "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two" }]')
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echoOne == "test-one"
-        getBatchedResponseContent()[0].data.echoTwo == null
-        getBatchedResponseContent()[1].data.echoOne == null
-        getBatchedResponseContent()[1].data.echoTwo == "test-two"
-    }
-
-    def "batched query over HTTP GET with empty non-null operationName returns data"() {
-        when:
-        response = new MockHttpServletResponse()
-        request.addParameter('query', '[{ "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }, { "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }]')
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP GET with unknown property 'test' returns data"() {
-        setup:
-        request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "Batch Execution Handler allows limiting batches and sending error messages."() {
-        setup:
-        servlet = TestUtils.createBatchCustomizedServlet({ env -> env.arguments.arg }, { env -> env.arguments.arg }, { env ->
-            AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
-            publisherRef.set(new SingleSubscriberPublisher<String>({
-                SingleSubscriberPublisher<String> publisher = publisherRef.get()
-                publisher.offer("First\n\n" + env.arguments.arg)
-                publisher.offer("Second\n\n" + env.arguments.arg)
-                publisher.noMoreData()
-                subscriptionLatch.countDown()
-            }))
-            return publisherRef.get()
-        })
-        request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_BAD_REQUEST
-        response.getErrorMessage() == TestBatchInputPreProcessor.BATCH_ERROR_MESSAGE
-    }
-
-    def "Default Execution Result Handler does not limit number of queries"() {
-        setup:
-        request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent().size() == 3
-    }
-
-    def "mutation over HTTP GET returns errors"() {
-        setup:
-        request.addParameter('query', 'mutation { echo(arg:"test") }')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().errors.size() == 1
-    }
-
-    def "batched mutation over HTTP GET returns errors"() {
-        setup:
-        request.addParameter('query', '[{ "query": "mutation { echo(arg:\\"test\\") }" }, { "query": "mutation {echo(arg:\\"test\\") }" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].errors.size() == 1
-        getBatchedResponseContent()[1].errors.size() == 1
-    }
-
-    def "subscription query over HTTP GET with variables as string returns data"() {
-        setup:
-        request.addParameter('query', 'subscription Subscription($arg: String!) { echo(arg: $arg) }')
-        request.addParameter('operationName', 'Subscription')
-        request.addParameter('variables', '{"arg": "test"}')
-        request.setAsyncSupported(true)
-
-        when:
-        servlet.doGet(request, response)
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_SERVER_SENT_EVENTS
-
-        when:
-        subscriptionLatch.await(1, TimeUnit.SECONDS)
-        then:
-        getSubscriptionResponseContent()[0].data.echo == "First\n\ntest"
-        getSubscriptionResponseContent()[1].data.echo == "Second\n\ntest"
-    }
-
-    def "query over HTTP POST without part or body returns bad request"() {
-        when:
-        request.setMethod("POST")
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_BAD_REQUEST
-    }
-
-    def "query over HTTP POST body returns data"() {
-        setup:
-        request.setContent(mapper.writeValueAsBytes([
-                query: 'query { echo(arg:"test") }'
-        ]))
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "disabling async support on request over HTTP POST does not start async request"() {
-        setup:
-        servlet = TestUtils.createDefaultServlet({ env -> env.arguments.arg }, { env -> env.arguments.arg }, { env ->
-            AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>();
-            publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
-                publisherRef.get().offer(env.arguments.arg)
-                publisherRef.get().noMoreData()
-            }))
-            return publisherRef.get()
-        })
-        request.setContent(mapper.writeValueAsBytes([
-                query: 'query { echo(arg:"test") }'
-        ]))
-        request.setAsyncSupported(false)
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        request.asyncContext == null
-    }
-
-    def "query over HTTP POST body with graphql contentType returns data"() {
-        setup:
-        request.addHeader("Content-Type", "application/graphql")
-        request.setContent('query { echo(arg:"test") }'.getBytes("UTF-8"))
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST body with variables returns data"() {
-        setup:
-        request.setContent(mapper.writeValueAsBytes([
-                query    : 'query Echo($arg: String) { echo(arg:$arg) }',
-                variables: '{"arg": "test"}'
-        ]))
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST body with operationName returns data"() {
-        setup:
-        request.setContent(mapper.writeValueAsBytes([
-                query        : 'query one{ echoOne: echo(arg:"test-one") } query two{ echoTwo: echo(arg:"test-two") }',
-                operationName: 'two'
-        ]))
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echoOne == null
-        getResponseContent().data.echoTwo == "test-two"
-    }
-
-    def "query over HTTP POST body with empty non-null operationName returns data"() {
-        setup:
-        request.setContent(mapper.writeValueAsBytes([
-                query        : 'query echo{ echo: echo(arg:"test") }',
-                operationName: ''
-        ]))
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST body with unknown property 'test' returns data"() {
-        setup:
-        request.setContent(mapper.writeValueAsBytes([
-                query: 'query { echo(arg:"test") }',
-                test : 'test'
-        ]))
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'graphql' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=---test")
-        request.setMethod("POST")
-
-        request.addPart(TestMultipartContentBuilder.createPart('graphql', mapper.writeValueAsString([query: 'query { echo(arg:"test") }'])))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'query' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', 'query { echo(arg:"test") }'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'query' with operationName returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', 'query one{ echoOne: echo(arg:"test-one") } query two{ echoTwo: echo(arg:"test-two") }'))
-        request.addPart(TestMultipartContentBuilder.createPart('operationName', 'two'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echoOne == null
-        getResponseContent().data.echoTwo == "test-two"
-    }
-
-    def "query over HTTP POST multipart named 'query' with empty non-null operationName returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', 'query echo{ echo: echo(arg:"test") }'))
-        request.addPart(TestMultipartContentBuilder.createPart('operationName', ''))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'query' with variables returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', 'query Echo($arg: String) { echo(arg:$arg) }'))
-        request.addPart(TestMultipartContentBuilder.createPart('variables', '{"arg": "test"}'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'query' with unknown property 'test' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', 'query { echo(arg:"test") }'))
-        request.addPart(TestMultipartContentBuilder.createPart('test', 'test'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'operations' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "query { echo(arg:\\"test\\") }"}'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'operations' with operationName returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two"}'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echoOne == null
-        getResponseContent().data.echoTwo == "test-two"
-    }
-
-    def "query over HTTP POST multipart named 'operations' with empty non-null operationName returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'operations' with variables returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "query Echo($arg: String) { echo(arg:$arg) }", "variables": {"arg": "test"} }'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'operations' with unknown property 'test' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '{\"query\": \"query { echo(arg:\\"test\\") }\"}'))
-        request.addPart(TestMultipartContentBuilder.createPart('test', 'test'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "query over HTTP POST multipart named 'operations' will interpolate variables from map"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "mutation test($file: Upload!) { echoFile(file: $file) }", "variables": { "file": null }}'))
-        request.addPart(TestMultipartContentBuilder.createPart('map', '{"0": ["variables.file"]}'))
-        request.addPart(TestMultipartContentBuilder.createPart('0', 'test'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echoFile == "test"
-    }
-
-    def "query over HTTP POST multipart named 'operations' will interpolate variable list from map"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "mutation test($files: [Upload!]!) { echoFiles(files: $files) }", "variables": { "files": [null, null] }}'))
-        request.addPart(TestMultipartContentBuilder.createPart('map', '{"0": ["variables.files.0"], "1": ["variables.files.1"]}'))
-        request.addPart(TestMultipartContentBuilder.createPart('0', 'test'))
-        request.addPart(TestMultipartContentBuilder.createPart('1', 'test again'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echoFiles == ["test", "test again"]
-    }
-
-    def "batched query over HTTP POST body returns data"() {
-        setup:
-        request.setContent('[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]'.bytes)
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        response.getContentLength() == mapper.writeValueAsString([["data": ["echo": "test"]], ["data": ["echo": "test"]]]).length()
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST body with variables returns data"() {
-        setup:
-        request.setContent('[{ "query": "query { echo(arg:\\"test\\") }", "variables": { "arg": "test" } }, { "query": "query { echo(arg:\\"test\\") }", "variables": { "arg": "test" } }]'.bytes)
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST body with operationName returns data"() {
-        setup:
-        request.setContent('[{ "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "one" }, { "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two" }]'.bytes)
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echoOne == "test-one"
-        getBatchedResponseContent()[0].data.echoTwo == null
-        getBatchedResponseContent()[1].data.echoOne == null
-        getBatchedResponseContent()[1].data.echoTwo == "test-two"
-    }
-
-    def "batched query over HTTP POST body with empty non-null operationName returns data"() {
-        setup:
-        request.setContent('[{ "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }, { "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }]'.bytes)
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST body with unknown property 'test' returns data"() {
-        setup:
-        request.setContent('[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]'.bytes)
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'graphql' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-
-        request.addPart(TestMultipartContentBuilder.createPart('graphql', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'graphql' with unknown property 'test' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-
-        request.addPart(TestMultipartContentBuilder.createPart('graphql', '[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'query' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'query' with operationName returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "one" }, { "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echoOne == "test-one"
-        getBatchedResponseContent()[0].data.echoTwo == null
-        getBatchedResponseContent()[1].data.echoOne == null
-        getBatchedResponseContent()[1].data.echoTwo == "test-two"
-    }
-
-    def "batched query over HTTP POST multipart named 'query' with empty non-null operationName returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }, { "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'query' with variables returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query echo($arg: String) { echo(arg:$arg) }", "variables": { "arg": "test" } }, { "query": "query echo($arg: String) { echo(arg:$arg) }", "variables": { "arg": "test" } }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'query' with unknown property 'test' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'operations' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'operations' with unknown property 'test' returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'operations' with operationName returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "one" }, { "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echoOne == "test-one"
-        getBatchedResponseContent()[0].data.echoTwo == null
-        getBatchedResponseContent()[1].data.echoOne == null
-        getBatchedResponseContent()[1].data.echoTwo == "test-two"
-    }
-
-    def "batched query over HTTP POST multipart named 'operations' with empty non-null operationName returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }, { "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched query over HTTP POST multipart named 'operations' with variables returns data"() {
-        setup:
-        request.setContentType("multipart/form-data, boundary=test")
-        request.setMethod("POST")
-        request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query echo($arg: String) { echo(arg:$arg) }", "variables": { "arg": "test" } }, { "query": "query echo($arg: String) { echo(arg:$arg) }", "variables": { "arg": "test" } }]'))
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "mutation over HTTP POST body returns data"() {
-        setup:
-        request.setContent(mapper.writeValueAsBytes([
-                query: 'mutation { echo(arg:"test") }'
-        ]))
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getResponseContent().data.echo == "test"
-    }
-
-    def "batched mutation over HTTP POST body returns data"() {
-        setup:
-        request.setContent('[{ "query": "mutation { echo(arg:\\"test\\") }" }, { "query": "mutation { echo(arg:\\"test\\") }" }]'.bytes)
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "batched mutation over HTTP POST body with unknown property 'test' returns data"() {
-        setup:
-        request.setContent('[{ "query": "mutation { echo(arg:\\"test\\") }", "test": "test" }, { "query": "mutation { echo(arg:\\"test\\") }", "test": "test" }]'.bytes)
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.echo == "test"
-        getBatchedResponseContent()[1].data.echo == "test"
-    }
-
-    def "subscription query over HTTP POST with variables as string returns data"() {
-        setup:
-        request.setContent('{"query": "subscription Subscription($arg: String!) { echo(arg: $arg) }", "operationName": "Subscription", "variables": {"arg": "test"}}'.bytes)
-        request.setAsyncSupported(true)
-        request.setMethod("POST")
-
-        when:
-        servlet.doPost(request, response)
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_SERVER_SENT_EVENTS
-
-        when:
-        subscriptionLatch.await(1, TimeUnit.SECONDS)
-        then:
-        getSubscriptionResponseContent()[0].data.echo == "First\n\ntest"
-        getSubscriptionResponseContent()[1].data.echo == "Second\n\ntest"
-    }
-
-    def "errors before graphql schema execution return internal server error"() {
-        setup:
-        GraphQLConfiguration configuration = GraphQLConfiguration.with(GraphQLInvocationInputFactory.newBuilder {
-            throw new TestException()
-        }.build()).build()
-        servlet = GraphQLHttpServlet.with(configuration)
-        servlet.init(null)
-
-        request.setPathInfo('/schema.json')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        noExceptionThrown()
-        response.getStatus() == STATUS_ERROR
-    }
-
-    def "errors while data fetching are masked in the response"() {
-        setup:
-        servlet = TestUtils.createDefaultServlet({ throw new TestException() })
-        request.addParameter('query', 'query { echo(arg:"test") }')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        def errors = getResponseContent().errors
-        errors.size() == 1
-        errors.first().message.startsWith("Internal Server Error(s)")
-    }
-
-    def "errors that also implement GraphQLError thrown while data fetching are passed to caller"() {
-        setup:
-        servlet = TestUtils.createDefaultServlet({ throw new TestGraphQLErrorException("This is a test message") })
-        request.addParameter('query', 'query { echo(arg:"test") }')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        def errors = getResponseContent().errors
-        errors.size() == 1
-        errors.first().extensions.foo == "bar"
-        errors.first().message.startsWith("Exception while fetching data (/echo) : This is a test message")
-    }
-
-    def "batched errors while data fetching are masked in the response"() {
-        setup:
-        servlet = TestUtils.createDefaultServlet({ throw new TestException() })
-        request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        def errors = getBatchedResponseContent().errors
-        errors[0].size() == 1
-        errors[0].first().message.startsWith("Internal Server Error(s)")
-        errors[1].size() == 1
-        errors[1].first().message.startsWith("Internal Server Error(s)")
-    }
-
-    def "data field is present and null if no data can be returned"() {
-        setup:
-        request.addParameter('query', 'query { not-a-field(arg:"test") }')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        def resp = getResponseContent()
-        resp.containsKey("data")
-        resp.data == null
-        resp.errors != null
-    }
-
-    def "batched data field is present and null if no data can be returned"() {
-        setup:
-        request.addParameter('query', '[{ "query": "query { not-a-field(arg:\\"test\\") }" }, { "query": "query { not-a-field(arg:\\"test\\") }" }]')
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        def resp = getBatchedResponseContent()
-        resp[0].containsKey("data")
-        resp[0].data == null
-        resp[0].errors != null
-        resp[1].containsKey("data")
-        resp[1].data == null
-        resp[1].errors != null
-    }
-
-    def "typeInfo is serialized correctly"() {
-        setup:
-        MergedField field = MergedField.newMergedField().addField(new Field("test")).build()
-        ExecutionStepInfo stepInfo = ExecutionStepInfo.newExecutionStepInfo().field(field).type(new GraphQLNonNull(Scalars.GraphQLString)).build()
-
-        expect:
-        servlet.getConfiguration().getObjectMapper().getJacksonMapper().writeValueAsString(stepInfo) != "{}"
-    }
+  public static final int STATUS_OK = 200
+  public static final int STATUS_BAD_REQUEST = 400
+  public static final int STATUS_ERROR = 500
+  public static final String CONTENT_TYPE_JSON_UTF8 = 'application/json;charset=UTF-8'
+  public static final String CONTENT_TYPE_SERVER_SENT_EVENTS = 'text/event-stream;charset=UTF-8'
+
+  @Shared
+  ObjectMapper mapper = new ObjectMapper()
+
+  AbstractGraphQLHttpServlet servlet
+  MockHttpServletRequest request
+  MockHttpServletResponse response
+  CountDownLatch subscriptionLatch
+
+  def setup() {
+    subscriptionLatch = new CountDownLatch(1)
+    servlet = TestUtils.createDefaultServlet({ env -> env.arguments.arg }, { env -> env.arguments.arg }, { env ->
+      AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+      publisherRef.set(new SingleSubscriberPublisher<String>({
+        SingleSubscriberPublisher<String> publisher = publisherRef.get()
+        publisher.offer("First\n\n" + env.arguments.arg)
+        publisher.offer("Second\n\n" + env.arguments.arg)
+        publisher.noMoreData()
+        subscriptionLatch.countDown()
+      }))
+      return publisherRef.get()
+    })
+
+    request = new MockHttpServletRequest()
+    request.setAsyncSupported(true)
+    request.asyncSupported = true
+    request.setMethod("GET")
+    response = new MockHttpServletResponse()
+  }
+
+
+  Map<String, Object> getResponseContent() {
+    mapper.readValue(response.getContentAsByteArray(), Map)
+  }
+
+  List<Map<String, Object>> getSubscriptionResponseContent() {
+    String[] data = response.getContentAsString().split("\n\n")
+    return data.collect { dataLine ->
+      if (dataLine.startsWith("data: ")) {
+        return mapper.readValue(dataLine.substring(5), Map)
+      } else {
+        throw new IllegalStateException("Could not read event stream")
+      }
+    }
+  }
+
+  List<Map<String, Object>> getBatchedResponseContent() {
+    mapper.readValue(response.getContentAsByteArray(), List)
+  }
+
+  def "HTTP GET without info returns bad request"() {
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_BAD_REQUEST
+  }
+
+  def "HTTP GET to /schema.json returns introspection query"() {
+    setup:
+    request.setPathInfo('/schema.json')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.__schema != null
+  }
+
+  def "query over HTTP GET returns data"() {
+    setup:
+    request.addParameter('query', 'query { echo(arg:"test") }')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    response.getContentLength() == mapper.writeValueAsString(["data": ["echo": "test"]]).getBytes(StandardCharsets.UTF_8).length
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP GET returns data with correct contentLength"() {
+    setup:
+    request.addParameter('query', 'query { echo(arg:"special char á") }')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    response.getContentLength() == mapper.writeValueAsString(["data": ["echo": "special char á"]]).getBytes(StandardCharsets.UTF_8).length
+    getResponseContent().data.echo == "special char á"
+  }
+
+  def "disabling async support on request over HTTP GET does not start async request"() {
+    setup:
+    servlet = TestUtils.createDefaultServlet({ env -> env.arguments.arg }, { env -> env.arguments.arg }, { env ->
+      AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+      publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
+        publisherRef.get().offer((String) env.arguments.arg)
+        publisherRef.get().noMoreData()
+      }))
+      return publisherRef.get()
+    })
+    request.addParameter('query', 'query { echo(arg:"test") }')
+    request.setAsyncSupported(false)
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    request.asyncContext == null
+  }
+
+  def "query over HTTP GET with variables returns data"() {
+    setup:
+    request.addParameter('query', 'query Echo($arg: String) { echo(arg:$arg) }')
+    request.addParameter('variables', '{"arg": "test"}')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP GET with variables as string returns data"() {
+    setup:
+    request.addParameter('query', 'query Echo($arg: String) { echo(arg:$arg) }')
+    request.addParameter('variables', '"{\\"arg\\": \\"test\\"}"')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP GET with operationName returns data"() {
+    when:
+    response = new MockHttpServletResponse()
+    request.addParameter('query', 'query one{ echoOne: echo(arg:"test-one") } query two{ echoTwo: echo(arg:"test-two") }')
+    request.addParameter('operationName', 'two')
+    servlet.doGet(request, response)
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echoOne == null
+    getResponseContent().data.echoTwo == "test-two"
+
+  }
+
+  def "query over HTTP GET with empty non-null operationName returns data"() {
+    when:
+    response = new MockHttpServletResponse()
+    request.addParameter('query', 'query echo{ echo: echo(arg:"test") }')
+    request.addParameter('operationName', '')
+    servlet.doGet(request, response)
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP GET with unknown property 'test' returns data"() {
+    setup:
+    request.addParameter('query', 'query { echo(arg:"test") }')
+    request.addParameter('test', 'test')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "batched query over HTTP GET returns data"() {
+    setup:
+    request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP GET returns data with correct contentLength"() {
+    setup:
+    request.addParameter('query', '[{ "query": "query { echo(arg:\\"special char á\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    response.getContentLength() == mapper.writeValueAsString([["data": ["echo": "special char á"]], ["data": ["echo": "test"]]]).getBytes(StandardCharsets.UTF_8).length
+    getBatchedResponseContent()[0].data.echo == "special char á"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP GET with variables returns data"() {
+    setup:
+    request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }", "variables": { "arg": "test" } }, { "query": "query { echo(arg:\\"test\\") }", "variables": { "arg": "test" } }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP GET with variables as string returns data"() {
+    setup:
+    request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }", "variables": "{ \\"arg\\": \\"test\\" }" }, { "query": "query { echo(arg:\\"test\\") }", "variables": "{ \\"arg\\": \\"test\\" }" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP GET with operationName returns data"() {
+    when:
+    response = new MockHttpServletResponse()
+    request.addParameter('query', '[{ "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "one" }, { "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two" }]')
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echoOne == "test-one"
+    getBatchedResponseContent()[0].data.echoTwo == null
+    getBatchedResponseContent()[1].data.echoOne == null
+    getBatchedResponseContent()[1].data.echoTwo == "test-two"
+  }
+
+  def "batched query over HTTP GET with empty non-null operationName returns data"() {
+    when:
+    response = new MockHttpServletResponse()
+    request.addParameter('query', '[{ "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }, { "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }]')
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP GET with unknown property 'test' returns data"() {
+    setup:
+    request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "Batch Execution Handler allows limiting batches and sending error messages."() {
+    setup:
+    servlet = TestUtils.createBatchCustomizedServlet({ env -> env.arguments.arg }, { env -> env.arguments.arg }, { env ->
+      AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+      publisherRef.set(new SingleSubscriberPublisher<String>({
+        SingleSubscriberPublisher<String> publisher = publisherRef.get()
+        publisher.offer("First\n\n" + env.arguments.arg)
+        publisher.offer("Second\n\n" + env.arguments.arg)
+        publisher.noMoreData()
+        subscriptionLatch.countDown()
+      }))
+      return publisherRef.get()
+    })
+    request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_BAD_REQUEST
+    response.getErrorMessage() == TestBatchInputPreProcessor.BATCH_ERROR_MESSAGE
+  }
+
+  def "Default Execution Result Handler does not limit number of queries"() {
+    setup:
+    request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent().size() == 3
+  }
+
+  def "mutation over HTTP GET returns errors"() {
+    setup:
+    request.addParameter('query', 'mutation { echo(arg:"test") }')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().errors.size() == 1
+  }
+
+  def "batched mutation over HTTP GET returns errors"() {
+    setup:
+    request.addParameter('query', '[{ "query": "mutation { echo(arg:\\"test\\") }" }, { "query": "mutation {echo(arg:\\"test\\") }" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].errors.size() == 1
+    getBatchedResponseContent()[1].errors.size() == 1
+  }
+
+  def "subscription query over HTTP GET with variables as string returns data"() {
+    setup:
+    request.addParameter('query', 'subscription Subscription($arg: String!) { echo(arg: $arg) }')
+    request.addParameter('operationName', 'Subscription')
+    request.addParameter('variables', '{"arg": "test"}')
+    request.setAsyncSupported(true)
+
+    when:
+    servlet.doGet(request, response)
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_SERVER_SENT_EVENTS
+
+    when:
+    subscriptionLatch.await(1, TimeUnit.SECONDS)
+    then:
+    getSubscriptionResponseContent()[0].data.echo == "First\n\ntest"
+    getSubscriptionResponseContent()[1].data.echo == "Second\n\ntest"
+  }
+
+  def "query over HTTP POST without part or body returns bad request"() {
+    when:
+    request.setMethod("POST")
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_BAD_REQUEST
+  }
+
+  def "query over HTTP POST body returns data"() {
+    setup:
+    request.setContent(mapper.writeValueAsBytes([
+        query: 'query { echo(arg:"test") }'
+    ]))
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "disabling async support on request over HTTP POST does not start async request"() {
+    setup:
+    servlet = TestUtils.createDefaultServlet({ env -> env.arguments.arg }, { env -> env.arguments.arg }, { env ->
+      AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+      publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
+        publisherRef.get().offer((String) env.arguments.arg)
+        publisherRef.get().noMoreData()
+      }))
+      return publisherRef.get()
+    })
+    request.setContent(mapper.writeValueAsBytes([
+        query: 'query { echo(arg:"test") }'
+    ]))
+    request.setAsyncSupported(false)
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    request.asyncContext == null
+  }
+
+  def "query over HTTP POST body with graphql contentType returns data"() {
+    setup:
+    request.addHeader("Content-Type", "application/graphql")
+    request.setContent('query { echo(arg:"test") }'.getBytes("UTF-8"))
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST body with variables returns data"() {
+    setup:
+    request.setContent(mapper.writeValueAsBytes([
+        query    : 'query Echo($arg: String) { echo(arg:$arg) }',
+        variables: '{"arg": "test"}'
+    ]))
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST body with operationName returns data"() {
+    setup:
+    request.setContent(mapper.writeValueAsBytes([
+        query        : 'query one{ echoOne: echo(arg:"test-one") } query two{ echoTwo: echo(arg:"test-two") }',
+        operationName: 'two'
+    ]))
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echoOne == null
+    getResponseContent().data.echoTwo == "test-two"
+  }
+
+  def "query over HTTP POST body with empty non-null operationName returns data"() {
+    setup:
+    request.setContent(mapper.writeValueAsBytes([
+        query        : 'query echo{ echo: echo(arg:"test") }',
+        operationName: ''
+    ]))
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST body with unknown property 'test' returns data"() {
+    setup:
+    request.setContent(mapper.writeValueAsBytes([
+        query: 'query { echo(arg:"test") }',
+        test : 'test'
+    ]))
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'graphql' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=---test")
+    request.setMethod("POST")
+
+    request.addPart(TestMultipartContentBuilder.createPart('graphql', mapper.writeValueAsString([query: 'query { echo(arg:"test") }'])))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'query' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', 'query { echo(arg:"test") }'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'query' with operationName returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', 'query one{ echoOne: echo(arg:"test-one") } query two{ echoTwo: echo(arg:"test-two") }'))
+    request.addPart(TestMultipartContentBuilder.createPart('operationName', 'two'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echoOne == null
+    getResponseContent().data.echoTwo == "test-two"
+  }
+
+  def "query over HTTP POST multipart named 'query' with empty non-null operationName returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', 'query echo{ echo: echo(arg:"test") }'))
+    request.addPart(TestMultipartContentBuilder.createPart('operationName', ''))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'query' with variables returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', 'query Echo($arg: String) { echo(arg:$arg) }'))
+    request.addPart(TestMultipartContentBuilder.createPart('variables', '{"arg": "test"}'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'query' with unknown property 'test' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', 'query { echo(arg:"test") }'))
+    request.addPart(TestMultipartContentBuilder.createPart('test', 'test'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'operations' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "query { echo(arg:\\"test\\") }"}'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'operations' with operationName returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two"}'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echoOne == null
+    getResponseContent().data.echoTwo == "test-two"
+  }
+
+  def "query over HTTP POST multipart named 'operations' with empty non-null operationName returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'operations' with variables returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "query Echo($arg: String) { echo(arg:$arg) }", "variables": {"arg": "test"} }'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'operations' with unknown property 'test' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '{\"query\": \"query { echo(arg:\\"test\\") }\"}'))
+    request.addPart(TestMultipartContentBuilder.createPart('test', 'test'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "query over HTTP POST multipart named 'operations' will interpolate variables from map"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "mutation test($file: Upload!) { echoFile(file: $file) }", "variables": { "file": null }}'))
+    request.addPart(TestMultipartContentBuilder.createPart('map', '{"0": ["variables.file"]}'))
+    request.addPart(TestMultipartContentBuilder.createPart('0', 'test'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echoFile == "test"
+  }
+
+  def "query over HTTP POST multipart named 'operations' will interpolate variable list from map"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '{"query": "mutation test($files: [Upload!]!) { echoFiles(files: $files) }", "variables": { "files": [null, null] }}'))
+    request.addPart(TestMultipartContentBuilder.createPart('map', '{"0": ["variables.files.0"], "1": ["variables.files.1"]}'))
+    request.addPart(TestMultipartContentBuilder.createPart('0', 'test'))
+    request.addPart(TestMultipartContentBuilder.createPart('1', 'test again'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echoFiles == ["test", "test again"]
+  }
+
+  def "batched query over HTTP POST body returns data"() {
+    setup:
+    request.setContent('[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]'.bytes)
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    response.getContentLength() == mapper.writeValueAsString([["data": ["echo": "test"]], ["data": ["echo": "test"]]]).length()
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST body with variables returns data"() {
+    setup:
+    request.setContent('[{ "query": "query { echo(arg:\\"test\\") }", "variables": { "arg": "test" } }, { "query": "query { echo(arg:\\"test\\") }", "variables": { "arg": "test" } }]'.bytes)
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST body with operationName returns data"() {
+    setup:
+    request.setContent('[{ "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "one" }, { "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two" }]'.bytes)
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echoOne == "test-one"
+    getBatchedResponseContent()[0].data.echoTwo == null
+    getBatchedResponseContent()[1].data.echoOne == null
+    getBatchedResponseContent()[1].data.echoTwo == "test-two"
+  }
+
+  def "batched query over HTTP POST body with empty non-null operationName returns data"() {
+    setup:
+    request.setContent('[{ "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }, { "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }]'.bytes)
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST body with unknown property 'test' returns data"() {
+    setup:
+    request.setContent('[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]'.bytes)
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'graphql' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+
+    request.addPart(TestMultipartContentBuilder.createPart('graphql', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'graphql' with unknown property 'test' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+
+    request.addPart(TestMultipartContentBuilder.createPart('graphql', '[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'query' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'query' with operationName returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "one" }, { "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echoOne == "test-one"
+    getBatchedResponseContent()[0].data.echoTwo == null
+    getBatchedResponseContent()[1].data.echoOne == null
+    getBatchedResponseContent()[1].data.echoTwo == "test-two"
+  }
+
+  def "batched query over HTTP POST multipart named 'query' with empty non-null operationName returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }, { "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'query' with variables returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query echo($arg: String) { echo(arg:$arg) }", "variables": { "arg": "test" } }, { "query": "query echo($arg: String) { echo(arg:$arg) }", "variables": { "arg": "test" } }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'query' with unknown property 'test' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('query', '[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'operations' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'operations' with unknown property 'test' returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query { echo(arg:\\"test\\") }", "test": "test" }, { "query": "query { echo(arg:\\"test\\") }", "test": "test" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'operations' with operationName returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "one" }, { "query": "query one{ echoOne: echo(arg:\\"test-one\\") } query two{ echoTwo: echo(arg:\\"test-two\\") }", "operationName": "two" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echoOne == "test-one"
+    getBatchedResponseContent()[0].data.echoTwo == null
+    getBatchedResponseContent()[1].data.echoOne == null
+    getBatchedResponseContent()[1].data.echoTwo == "test-two"
+  }
+
+  def "batched query over HTTP POST multipart named 'operations' with empty non-null operationName returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }, { "query": "query echo{ echo: echo(arg:\\"test\\") }", "operationName": "" }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched query over HTTP POST multipart named 'operations' with variables returns data"() {
+    setup:
+    request.setContentType("multipart/form-data, boundary=test")
+    request.setMethod("POST")
+    request.addPart(TestMultipartContentBuilder.createPart('operations', '[{ "query": "query echo($arg: String) { echo(arg:$arg) }", "variables": { "arg": "test" } }, { "query": "query echo($arg: String) { echo(arg:$arg) }", "variables": { "arg": "test" } }]'))
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "mutation over HTTP POST body returns data"() {
+    setup:
+    request.setContent(mapper.writeValueAsBytes([
+        query: 'mutation { echo(arg:"test") }'
+    ]))
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getResponseContent().data.echo == "test"
+  }
+
+  def "batched mutation over HTTP POST body returns data"() {
+    setup:
+    request.setContent('[{ "query": "mutation { echo(arg:\\"test\\") }" }, { "query": "mutation { echo(arg:\\"test\\") }" }]'.bytes)
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "batched mutation over HTTP POST body with unknown property 'test' returns data"() {
+    setup:
+    request.setContent('[{ "query": "mutation { echo(arg:\\"test\\") }", "test": "test" }, { "query": "mutation { echo(arg:\\"test\\") }", "test": "test" }]'.bytes)
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.echo == "test"
+    getBatchedResponseContent()[1].data.echo == "test"
+  }
+
+  def "subscription query over HTTP POST with variables as string returns data"() {
+    setup:
+    request.setContent('{"query": "subscription Subscription($arg: String!) { echo(arg: $arg) }", "operationName": "Subscription", "variables": {"arg": "test"}}'.bytes)
+    request.setAsyncSupported(true)
+    request.setMethod("POST")
+
+    when:
+    servlet.doPost(request, response)
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_SERVER_SENT_EVENTS
+
+    when:
+    subscriptionLatch.await(1, TimeUnit.SECONDS)
+    then:
+    getSubscriptionResponseContent()[0].data.echo == "First\n\ntest"
+    getSubscriptionResponseContent()[1].data.echo == "Second\n\ntest"
+  }
+
+  def "errors before graphql schema execution return internal server error"() {
+    setup:
+    GraphQLConfiguration configuration = GraphQLConfiguration.with(GraphQLInvocationInputFactory.newBuilder {
+      throw new TestException()
+    }.build()).build()
+    servlet = GraphQLHttpServlet.with(configuration)
+    servlet.init(null)
+
+    request.setPathInfo('/schema.json')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    noExceptionThrown()
+    response.getStatus() == STATUS_ERROR
+  }
+
+  def "errors while data fetching are masked in the response"() {
+    setup:
+    servlet = TestUtils.createDefaultServlet({ throw new TestException() })
+    request.addParameter('query', 'query { echo(arg:"test") }')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    def errors = getResponseContent().errors
+    errors.size() == 1
+    errors.first().message.startsWith("Internal Server Error(s)")
+  }
+
+  def "errors that also implement GraphQLError thrown while data fetching are passed to caller"() {
+    setup:
+    servlet = TestUtils.createDefaultServlet({ throw new TestGraphQLErrorException("This is a test message") })
+    request.addParameter('query', 'query { echo(arg:"test") }')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    def errors = getResponseContent().errors
+    errors.size() == 1
+    errors.first().extensions.foo == "bar"
+    errors.first().message.startsWith("Exception while fetching data (/echo) : This is a test message")
+  }
+
+  def "batched errors while data fetching are masked in the response"() {
+    setup:
+    servlet = TestUtils.createDefaultServlet({ throw new TestException() })
+    request.addParameter('query', '[{ "query": "query { echo(arg:\\"test\\") }" }, { "query": "query { echo(arg:\\"test\\") }" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    def errors = getBatchedResponseContent().errors
+    errors[0].size() == 1
+    errors[0].first().message.startsWith("Internal Server Error(s)")
+    errors[1].size() == 1
+    errors[1].first().message.startsWith("Internal Server Error(s)")
+  }
+
+  def "data field is present and null if no data can be returned"() {
+    setup:
+    request.addParameter('query', 'query { not-a-field(arg:"test") }')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    def resp = getResponseContent()
+    resp.containsKey("data")
+    resp.data == null
+    resp.errors != null
+  }
+
+  def "batched data field is present and null if no data can be returned"() {
+    setup:
+    request.addParameter('query', '[{ "query": "query { not-a-field(arg:\\"test\\") }" }, { "query": "query { not-a-field(arg:\\"test\\") }" }]')
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    def resp = getBatchedResponseContent()
+    resp[0].containsKey("data")
+    resp[0].data == null
+    resp[0].errors != null
+    resp[1].containsKey("data")
+    resp[1].data == null
+    resp[1].errors != null
+  }
+
+  def "typeInfo is serialized correctly"() {
+    setup:
+    MergedField field = MergedField.newMergedField().addField(new Field("test")).build()
+    ExecutionStepInfo stepInfo = ExecutionStepInfo.newExecutionStepInfo().field(field).type(new GraphQLNonNull(Scalars.GraphQLString)).build()
+
+    expect:
+    servlet.getConfiguration().getObjectMapper().getJacksonMapper().writeValueAsString(stepInfo) != "{}"
+  }
 
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/BatchedQueryResponseWriterTest.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/BatchedQueryResponseWriterTest.groovy
index 3b7af23f..f9a9b369 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/BatchedQueryResponseWriterTest.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/BatchedQueryResponseWriterTest.groovy
@@ -13,43 +13,43 @@ import java.nio.charset.StandardCharsets
 
 class BatchedQueryResponseWriterTest extends Specification {
 
-    @Unroll
-    def "should write utf8 results into the response with content #result"() {
-        given:
-        def byteArrayOutputStream = new ByteArrayOutputStream()
-        def graphQLObjectMapperMock = GraphQLObjectMapper.newBuilder().withObjectMapperProvider({ new ObjectMapper() }).build()
-        graphQLObjectMapperMock.getJacksonMapper() >> new ObjectMapper()
-
-        def requestMock = Mock(HttpServletRequest)
-        def responseMock = Mock(HttpServletResponse)
-        def servletOutputStreamMock = Mock(ServletOutputStream)
-
-        responseMock.getOutputStream() >> servletOutputStreamMock
-
-        1 * responseMock.setContentLength(expectedContentLengh)
-        1 * responseMock.setCharacterEncoding(StandardCharsets.UTF_8.name())
-        (1.._) * servletOutputStreamMock.write(_) >> { value ->
-            byteArrayOutputStream.write((byte[])(value[0]))
-        }
-
-        def executionResultList = new ArrayList()
-        for (LinkedHashMap<Object, Object> value : result) {
-            executionResultList.add(new ExecutionResultImpl(value, []))
-        }
-
-        def writer = new BatchedQueryResponseWriter(executionResultList, graphQLObjectMapperMock)
-
-        when:
-        writer.write(requestMock, responseMock)
-
-        then:
-        byteArrayOutputStream.toString(StandardCharsets.UTF_8.name()) == expectedResponseContent
-
-        where:
-        result                      || expectedContentLengh | expectedResponseContent
-        [[testValue: "abcde"]]      || 32                   | """[{"data":{"testValue":"abcde"}}]"""
-        [[testValue: "äöüüöß"]]     || 39                   | """[{"data":{"testValue":"äöüüöß"}}]"""
-        []                          || 2                    | """[]"""
-        [[k1: "äöüüöß"], [k2: "a"]] || 52                   | """[{"data":{"k1":"äöüüöß"}},{"data":{"k2":"a"}}]"""
+  @Unroll
+  def "should write utf8 results into the response with content #result"() {
+    given:
+    def byteArrayOutputStream = new ByteArrayOutputStream()
+    def graphQLObjectMapperMock = GraphQLObjectMapper.newBuilder().withObjectMapperProvider({ new ObjectMapper() }).build()
+    graphQLObjectMapperMock.getJacksonMapper() >> new ObjectMapper()
+
+    def requestMock = Mock(HttpServletRequest)
+    def responseMock = Mock(HttpServletResponse)
+    def servletOutputStreamMock = Mock(ServletOutputStream)
+
+    responseMock.getOutputStream() >> servletOutputStreamMock
+
+    1 * responseMock.setContentLength(expectedContentLengh)
+    1 * responseMock.setCharacterEncoding(StandardCharsets.UTF_8.name())
+    (1.._) * servletOutputStreamMock.write(_) >> { value ->
+      byteArrayOutputStream.write((byte[]) (value[0]))
     }
+
+    def executionResultList = new ArrayList()
+    for (LinkedHashMap<Object, Object> value : result) {
+      executionResultList.add(new ExecutionResultImpl(value, []))
+    }
+
+    def writer = new BatchedQueryResponseWriter(executionResultList, graphQLObjectMapperMock)
+
+    when:
+    writer.write(requestMock, responseMock)
+
+    then:
+    byteArrayOutputStream.toString(StandardCharsets.UTF_8.name()) == expectedResponseContent
+
+    where:
+    result                      || expectedContentLengh | expectedResponseContent
+    [[testValue: "abcde"]]      || 32                   | """[{"data":{"testValue":"abcde"}}]"""
+    [[testValue: "äöüüöß"]]     || 39                   | """[{"data":{"testValue":"äöüüöß"}}]"""
+    []                          || 2                    | """[]"""
+    [[k1: "äöüüöß"], [k2: "a"]] || 52                   | """[{"data":{"k1":"äöüüöß"}},{"data":{"k2":"a"}}]"""
+  }
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/DataLoaderDispatchingSpec.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/DataLoaderDispatchingSpec.groovy
index c2153fac..182936d7 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/DataLoaderDispatchingSpec.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/DataLoaderDispatchingSpec.groovy
@@ -30,223 +30,223 @@ import java.util.concurrent.atomic.AtomicInteger
 
 class DataLoaderDispatchingSpec extends Specification {
 
-    public static final int STATUS_OK = 200
-    public static final String CONTENT_TYPE_JSON_UTF8 = 'application/json;charset=UTF-8'
-
-    @Shared
-    ObjectMapper mapper = new ObjectMapper()
-
-    AbstractGraphQLHttpServlet servlet
-    MockHttpServletRequest request
-    MockHttpServletResponse response
-    AtomicInteger fetchCounterA = new AtomicInteger()
-    AtomicInteger loadCounterA = new AtomicInteger()
-    AtomicInteger fetchCounterB = new AtomicInteger()
-    AtomicInteger loadCounterB = new AtomicInteger()
-    AtomicInteger fetchCounterC = new AtomicInteger()
-    AtomicInteger loadCounterC = new AtomicInteger()
-
-    BatchLoader<String, String> batchLoaderWithCounter(AtomicInteger fetchCounter) {
-        return new BatchLoader<String, String>() {
-            @Override
-            CompletionStage<List<String>> load(List<String> keys) {
-                fetchCounter.incrementAndGet()
-                CompletableFuture.completedFuture(keys)
-            }
-        }
-    }
-
-    def registry() {
-        DataLoaderRegistry registry = new DataLoaderRegistry()
-        registry.register("A", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterA)))
-        registry.register("B", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterB)))
-        registry.register("C", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterC)))
-        registry
-    }
-
-    def setup() {
-        request = new MockHttpServletRequest()
-        request.setAsyncSupported(true)
-        request.asyncSupported = true
-        response = new MockHttpServletResponse()
-    }
-
-    def queryDataFetcher(String dataLoaderName, AtomicInteger loadCounter) {
-        return new DataFetcher() {
-            @Override
-            Object get(DataFetchingEnvironment environment) {
-                String id = environment.arguments.arg
-                loadCounter.incrementAndGet()
-                environment.getDataLoader(dataLoaderName).load(id)
-            }
-        }
-    }
-
-    def contextBuilder() {
-        return new graphql.kickstart.servlet.context.GraphQLServletContextBuilder() {
-            @Override
-            GraphQLContext build(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {
-                new DefaultGraphQLContext(registry(), null)
-            }
-
-            @Override
-            GraphQLContext build(Session session, HandshakeRequest handshakeRequest) {
-                new DefaultGraphQLContext(registry(), null)
-            }
-
-            @Override
-            GraphQLContext build() {
-                new DefaultGraphQLContext(registry(), null)
-            }
-        }
-    }
-
-    def configureServlet(ContextSetting contextSetting) {
-        servlet = TestUtils.createDataLoadingServlet(queryDataFetcher("A", loadCounterA),
-                queryDataFetcher("B", loadCounterB), queryDataFetcher("C", loadCounterC)
-                , contextSetting,
-                contextBuilder())
-    }
-
-    def resetCounters() {
-        fetchCounterA.set(0)
-        fetchCounterB.set(0)
-        loadCounterA.set(0)
-        loadCounterB.set(0)
+  public static final int STATUS_OK = 200
+  public static final String CONTENT_TYPE_JSON_UTF8 = 'application/json;charset=UTF-8'
+
+  @Shared
+  ObjectMapper mapper = new ObjectMapper()
+
+  AbstractGraphQLHttpServlet servlet
+  MockHttpServletRequest request
+  MockHttpServletResponse response
+  AtomicInteger fetchCounterA = new AtomicInteger()
+  AtomicInteger loadCounterA = new AtomicInteger()
+  AtomicInteger fetchCounterB = new AtomicInteger()
+  AtomicInteger loadCounterB = new AtomicInteger()
+  AtomicInteger fetchCounterC = new AtomicInteger()
+  AtomicInteger loadCounterC = new AtomicInteger()
+
+  BatchLoader<String, String> batchLoaderWithCounter(AtomicInteger fetchCounter) {
+    return new BatchLoader<String, String>() {
+      @Override
+      CompletionStage<List<String>> load(List<String> keys) {
+        fetchCounter.incrementAndGet()
+        CompletableFuture.completedFuture(keys)
+      }
     }
-
-    List<Map<String, Object>> getBatchedResponseContent() {
-        mapper.readValue(response.getContentAsByteArray(), List)
+  }
+
+  def registry() {
+    DataLoaderRegistry registry = new DataLoaderRegistry()
+    registry.register("A", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterA)))
+    registry.register("B", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterB)))
+    registry.register("C", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterC)))
+    registry
+  }
+
+  def setup() {
+    request = new MockHttpServletRequest()
+    request.setAsyncSupported(true)
+    request.asyncSupported = true
+    response = new MockHttpServletResponse()
+  }
+
+  def queryDataFetcher(String dataLoaderName, AtomicInteger loadCounter) {
+    return new DataFetcher() {
+      @Override
+      Object get(DataFetchingEnvironment environment) {
+        String id = environment.arguments.arg
+        loadCounter.incrementAndGet()
+        environment.getDataLoader(dataLoaderName).load(id)
+      }
     }
-
-    Instrumentation simpleInstrumentation = new SimpleInstrumentation()
-    ChainedInstrumentation chainedInstrumentation = new ChainedInstrumentation(Collections.singletonList(simpleInstrumentation))
-    def simpleSupplier = { simpleInstrumentation }
-    def chainedSupplier = { chainedInstrumentation }
-
-    def "batched query with per query context does not batch loads together"() {
-        setup:
-        configureServlet(ContextSetting.PER_QUERY_WITH_INSTRUMENTATION)
-        request.addParameter('query', '[{ "query": "query { query(arg:\\"test\\") { echo(arg:\\"test\\") { echo(arg:\\"test\\") } }}" }, { "query": "query{query(arg:\\"test\\") { echo (arg:\\"test\\") { echo(arg:\\"test\\")} }}" },' +
-                ' { "query": "query{queryTwo(arg:\\"test\\") { echo (arg:\\"test\\")}}" }, { "query": "query{queryTwo(arg:\\"test\\") { echo (arg:\\"test\\")}}" }]')
-        resetCounters()
-        request.setMethod("GET")
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.query.echo.echo == "test"
-        getBatchedResponseContent()[1].data.query.echo.echo == "test"
-        getBatchedResponseContent()[2].data.queryTwo.echo == "test"
-        getBatchedResponseContent()[3].data.queryTwo.echo == "test"
-        fetchCounterA.get() == 2
-        loadCounterA.get() == 2
-        fetchCounterB.get() == 2
-        loadCounterB.get() == 2
-        fetchCounterC.get() == 2
-        loadCounterC.get() == 2
+  }
+
+  def contextBuilder() {
+    return new graphql.kickstart.servlet.context.GraphQLServletContextBuilder() {
+      @Override
+      GraphQLContext build(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {
+        new DefaultGraphQLContext(registry(), null)
+      }
+
+      @Override
+      GraphQLContext build(Session session, HandshakeRequest handshakeRequest) {
+        new DefaultGraphQLContext(registry(), null)
+      }
+
+      @Override
+      GraphQLContext build() {
+        new DefaultGraphQLContext(registry(), null)
+      }
     }
-
-    def "batched query with per request context batches all queries within the request"() {
-        setup:
-        servlet = configureServlet(ContextSetting.PER_REQUEST_WITH_INSTRUMENTATION)
-        request.addParameter('query', '[{ "query": "query { query(arg:\\"test\\") { echo(arg:\\"test\\") { echo(arg:\\"test\\") } }}" }, { "query": "query{query(arg:\\"test\\") { echo (arg:\\"test\\") { echo(arg:\\"test\\")} }}" },' +
-                ' { "query": "query{queryTwo(arg:\\"test\\") { echo (arg:\\"test\\")}}" }, { "query": "query{queryTwo(arg:\\"test\\") { echo (arg:\\"test\\")}}" }]')
-        resetCounters()
-        request.setMethod("GET")
-
-        when:
-        servlet.doGet(request, response)
-
-        then:
-        response.getStatus() == STATUS_OK
-        response.getContentType() == CONTENT_TYPE_JSON_UTF8
-        getBatchedResponseContent()[0].data.query.echo.echo == "test"
-        getBatchedResponseContent()[1].data.query.echo.echo == "test"
-        getBatchedResponseContent()[2].data.queryTwo.echo == "test"
-        getBatchedResponseContent()[3].data.queryTwo.echo == "test"
-        fetchCounterA.get() == 1
-        loadCounterA.get() == 2
-        fetchCounterB.get() == 1
-        loadCounterB.get() == 2
-        fetchCounterC.get() == 1
-        loadCounterC.get() == 2
-    }
-
-    def unwrapChainedInstrumentations(Instrumentation instrumentation) {
-        if (!instrumentation instanceof ChainedInstrumentation) {
-            return Collections.singletonList(instrumentation)
+  }
+
+  def configureServlet(ContextSetting contextSetting) {
+    servlet = TestUtils.createDataLoadingServlet(queryDataFetcher("A", loadCounterA),
+        queryDataFetcher("B", loadCounterB), queryDataFetcher("C", loadCounterC)
+        , contextSetting,
+        contextBuilder())
+  }
+
+  def resetCounters() {
+    fetchCounterA.set(0)
+    fetchCounterB.set(0)
+    loadCounterA.set(0)
+    loadCounterB.set(0)
+  }
+
+  List<Map<String, Object>> getBatchedResponseContent() {
+    mapper.readValue(response.getContentAsByteArray(), List)
+  }
+
+  Instrumentation simpleInstrumentation = new SimpleInstrumentation()
+  ChainedInstrumentation chainedInstrumentation = new ChainedInstrumentation(Collections.singletonList(simpleInstrumentation))
+  def simpleSupplier = { simpleInstrumentation }
+  def chainedSupplier = { chainedInstrumentation }
+
+  def "batched query with per query context does not batch loads together"() {
+    setup:
+    configureServlet(ContextSetting.PER_QUERY_WITH_INSTRUMENTATION)
+    request.addParameter('query', '[{ "query": "query { query(arg:\\"test\\") { echo(arg:\\"test\\") { echo(arg:\\"test\\") } }}" }, { "query": "query{query(arg:\\"test\\") { echo (arg:\\"test\\") { echo(arg:\\"test\\")} }}" },' +
+        ' { "query": "query{queryTwo(arg:\\"test\\") { echo (arg:\\"test\\")}}" }, { "query": "query{queryTwo(arg:\\"test\\") { echo (arg:\\"test\\")}}" }]')
+    resetCounters()
+    request.setMethod("GET")
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.query.echo.echo == "test"
+    getBatchedResponseContent()[1].data.query.echo.echo == "test"
+    getBatchedResponseContent()[2].data.queryTwo.echo == "test"
+    getBatchedResponseContent()[3].data.queryTwo.echo == "test"
+    fetchCounterA.get() == 2
+    loadCounterA.get() == 2
+    fetchCounterB.get() == 2
+    loadCounterB.get() == 2
+    fetchCounterC.get() == 2
+    loadCounterC.get() == 2
+  }
+
+  def "batched query with per request context batches all queries within the request"() {
+    setup:
+    servlet = configureServlet(ContextSetting.PER_REQUEST_WITH_INSTRUMENTATION)
+    request.addParameter('query', '[{ "query": "query { query(arg:\\"test\\") { echo(arg:\\"test\\") { echo(arg:\\"test\\") } }}" }, { "query": "query{query(arg:\\"test\\") { echo (arg:\\"test\\") { echo(arg:\\"test\\")} }}" },' +
+        ' { "query": "query{queryTwo(arg:\\"test\\") { echo (arg:\\"test\\")}}" }, { "query": "query{queryTwo(arg:\\"test\\") { echo (arg:\\"test\\")}}" }]')
+    resetCounters()
+    request.setMethod("GET")
+
+    when:
+    servlet.doGet(request, response)
+
+    then:
+    response.getStatus() == STATUS_OK
+    response.getContentType() == CONTENT_TYPE_JSON_UTF8
+    getBatchedResponseContent()[0].data.query.echo.echo == "test"
+    getBatchedResponseContent()[1].data.query.echo.echo == "test"
+    getBatchedResponseContent()[2].data.queryTwo.echo == "test"
+    getBatchedResponseContent()[3].data.queryTwo.echo == "test"
+    fetchCounterA.get() == 1
+    loadCounterA.get() == 2
+    fetchCounterB.get() == 1
+    loadCounterB.get() == 2
+    fetchCounterC.get() == 1
+    loadCounterC.get() == 2
+  }
+
+  def unwrapChainedInstrumentations(Instrumentation instrumentation) {
+    if (!instrumentation instanceof ChainedInstrumentation) {
+      return Collections.singletonList(instrumentation)
+    } else {
+      List<Instrumentation> instrumentations = new ArrayList<>()
+      for (Instrumentation current : ((ChainedInstrumentation) instrumentation).getInstrumentations()) {
+        if (current instanceof ChainedInstrumentation) {
+          instrumentations.addAll(unwrapChainedInstrumentations(current))
         } else {
-            List<Instrumentation> instrumentations = new ArrayList<>()
-            for (Instrumentation current : ((ChainedInstrumentation) instrumentation).getInstrumentations()) {
-                if (current instanceof ChainedInstrumentation) {
-                    instrumentations.addAll(unwrapChainedInstrumentations(current))
-                } else {
-                    instrumentations.add(current)
-                }
-            }
-            return instrumentations
+          instrumentations.add(current)
         }
+      }
+      return instrumentations
     }
-
-    def "PER_QUERY_WITHOUT_INSTRUMENTATION does not add instrumentation"() {
-        when:
-        def chainedFromContext = ContextSetting.PER_QUERY_WITHOUT_INSTRUMENTATION
-                .configureInstrumentationForContext(chainedSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
-        def simpleFromContext = ContextSetting.PER_QUERY_WITHOUT_INSTRUMENTATION
-                .configureInstrumentationForContext(simpleSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
-        then:
-        simpleInstrumentation == simpleFromContext.get()
-        chainedInstrumentation == chainedFromContext.get()
-    }
-
-    def "PER_REQUEST_WITHOUT_INSTRUMENTATION does not add instrumentation"() {
-        when:
-        def chainedFromContext = ContextSetting.PER_REQUEST_WITHOUT_INSTRUMENTATION
-                .configureInstrumentationForContext(chainedSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
-        def simpleFromContext = ContextSetting.PER_REQUEST_WITHOUT_INSTRUMENTATION
-                .configureInstrumentationForContext(simpleSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
-        then:
-        simpleInstrumentation == simpleFromContext.get()
-        chainedInstrumentation == chainedFromContext.get()
-    }
-
-    def "PER_QUERY_WITH_INSTRUMENTATION adds instrumentation"() {
-        when:
-        def chainedFromContext = ContextSetting.PER_QUERY_WITH_INSTRUMENTATION
-                .configureInstrumentationForContext(chainedSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
-        def simpleFromContext = ContextSetting.PER_QUERY_WITH_INSTRUMENTATION
-                .configureInstrumentationForContext(simpleSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
-        def fromSimple = unwrapChainedInstrumentations(simpleFromContext.get())
-        def fromChained = unwrapChainedInstrumentations(chainedFromContext.get())
-        then:
-        fromSimple.size() == 2
-        fromSimple.contains(simpleInstrumentation)
-        fromSimple.stream().anyMatch({ inst -> inst instanceof ConfigurableDispatchInstrumentation })
-        fromChained.size() == 2
-        fromChained.contains(simpleInstrumentation)
-        fromChained.stream().anyMatch({ inst -> inst instanceof ConfigurableDispatchInstrumentation })
-    }
-
-    def "PER_REQUEST_WITH_INSTRUMENTATION adds instrumentation"() {
-        setup:
-        ExecutionInput mockInput = ExecutionInput.newExecutionInput().query("query { query(arg:\"test\")").dataLoaderRegistry(new DataLoaderRegistry()).build()
-        when:
-        def chainedFromContext = ContextSetting.PER_REQUEST_WITH_INSTRUMENTATION
-                .configureInstrumentationForContext(chainedSupplier, Collections.singletonList(mockInput), DataLoaderDispatcherInstrumentationOptions.newOptions())
-        def simpleFromContext = ContextSetting.PER_REQUEST_WITH_INSTRUMENTATION
-                .configureInstrumentationForContext(simpleSupplier, Collections.singletonList(mockInput), DataLoaderDispatcherInstrumentationOptions.newOptions())
-        def fromSimple = unwrapChainedInstrumentations(simpleFromContext.get())
-        def fromChained = unwrapChainedInstrumentations(chainedFromContext.get())
-        then:
-        fromSimple.size() == 2
-        fromSimple.contains(simpleInstrumentation)
-        fromSimple.stream().anyMatch({ inst -> inst instanceof ConfigurableDispatchInstrumentation })
-        fromChained.size() == 2
-        fromChained.contains(simpleInstrumentation)
-        fromChained.stream().anyMatch({ inst -> inst instanceof ConfigurableDispatchInstrumentation })
-    }
+  }
+
+  def "PER_QUERY_WITHOUT_INSTRUMENTATION does not add instrumentation"() {
+    when:
+    def chainedFromContext = ContextSetting.PER_QUERY_WITHOUT_INSTRUMENTATION
+        .configureInstrumentationForContext(chainedSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
+    def simpleFromContext = ContextSetting.PER_QUERY_WITHOUT_INSTRUMENTATION
+        .configureInstrumentationForContext(simpleSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
+    then:
+    simpleInstrumentation == simpleFromContext.get()
+    chainedInstrumentation == chainedFromContext.get()
+  }
+
+  def "PER_REQUEST_WITHOUT_INSTRUMENTATION does not add instrumentation"() {
+    when:
+    def chainedFromContext = ContextSetting.PER_REQUEST_WITHOUT_INSTRUMENTATION
+        .configureInstrumentationForContext(chainedSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
+    def simpleFromContext = ContextSetting.PER_REQUEST_WITHOUT_INSTRUMENTATION
+        .configureInstrumentationForContext(simpleSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
+    then:
+    simpleInstrumentation == simpleFromContext.get()
+    chainedInstrumentation == chainedFromContext.get()
+  }
+
+  def "PER_QUERY_WITH_INSTRUMENTATION adds instrumentation"() {
+    when:
+    def chainedFromContext = ContextSetting.PER_QUERY_WITH_INSTRUMENTATION
+        .configureInstrumentationForContext(chainedSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
+    def simpleFromContext = ContextSetting.PER_QUERY_WITH_INSTRUMENTATION
+        .configureInstrumentationForContext(simpleSupplier, Collections.emptyList(), DataLoaderDispatcherInstrumentationOptions.newOptions())
+    def fromSimple = unwrapChainedInstrumentations(simpleFromContext.get())
+    def fromChained = unwrapChainedInstrumentations(chainedFromContext.get())
+    then:
+    fromSimple.size() == 2
+    fromSimple.contains(simpleInstrumentation)
+    fromSimple.stream().anyMatch({ inst -> inst instanceof ConfigurableDispatchInstrumentation })
+    fromChained.size() == 2
+    fromChained.contains(simpleInstrumentation)
+    fromChained.stream().anyMatch({ inst -> inst instanceof ConfigurableDispatchInstrumentation })
+  }
+
+  def "PER_REQUEST_WITH_INSTRUMENTATION adds instrumentation"() {
+    setup:
+    ExecutionInput mockInput = ExecutionInput.newExecutionInput().query("query { query(arg:\"test\")").dataLoaderRegistry(new DataLoaderRegistry()).build()
+    when:
+    def chainedFromContext = ContextSetting.PER_REQUEST_WITH_INSTRUMENTATION
+        .configureInstrumentationForContext(chainedSupplier, Collections.singletonList(mockInput), DataLoaderDispatcherInstrumentationOptions.newOptions())
+    def simpleFromContext = ContextSetting.PER_REQUEST_WITH_INSTRUMENTATION
+        .configureInstrumentationForContext(simpleSupplier, Collections.singletonList(mockInput), DataLoaderDispatcherInstrumentationOptions.newOptions())
+    def fromSimple = unwrapChainedInstrumentations(simpleFromContext.get())
+    def fromChained = unwrapChainedInstrumentations(chainedFromContext.get())
+    then:
+    fromSimple.size() == 2
+    fromSimple.contains(simpleInstrumentation)
+    fromSimple.stream().anyMatch({ inst -> inst instanceof ConfigurableDispatchInstrumentation })
+    fromChained.size() == 2
+    fromChained.contains(simpleInstrumentation)
+    fromChained.stream().anyMatch({ inst -> inst instanceof ConfigurableDispatchInstrumentation })
+  }
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/GraphQLServletListenerSpec.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/GraphQLServletListenerSpec.groovy
new file mode 100644
index 00000000..01575d8f
--- /dev/null
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/GraphQLServletListenerSpec.groovy
@@ -0,0 +1,44 @@
+package graphql.kickstart.servlet
+
+import graphql.kickstart.servlet.core.GraphQLServletListener
+import spock.lang.Specification
+
+class GraphQLServletListenerSpec extends Specification {
+
+  def listener = Mock(GraphQLServletListener)
+  def requestCallback = Mock(GraphQLServletListener.RequestCallback)
+  def tester = new RequestTester(listener)
+
+  def "query over HTTP GET calls onRequest listener"() {
+    given: "a valid graphql query request"
+    tester.addParameter('query', 'query { echo(arg:"test") }')
+
+    and: "a listener that always returns request callback"
+    listener.onRequest(tester.request, tester.response) >> requestCallback
+
+    when: "we execute a GET request"
+    tester.doGet()
+
+    then:
+    tester.assertThatResponseIsOk()
+    tester.assertThatContentTypeIsJson()
+    1 * listener.onRequest(tester.request, tester.response)
+  }
+
+  def "query over HTTP GET calls onSuccess callback"() {
+    given: "a valid graphql query request"
+    tester.addParameter('query', 'query { echo(arg:"test") }')
+
+    and: "a listener that always returns request callback"
+    listener.onRequest(tester.request, tester.response) >> requestCallback
+
+    when: "we execute a GET request"
+    tester.doGet()
+
+    then:
+    tester.assertThatResponseIsOk()
+    tester.assertThatContentTypeIsJson()
+    1 * requestCallback.onSuccess(tester.request, tester.response)
+  }
+
+}
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/OsgiGraphQLHttpServletSpec.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/OsgiGraphQLHttpServletSpec.groovy
index 274762c7..6de50bba 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/OsgiGraphQLHttpServletSpec.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/OsgiGraphQLHttpServletSpec.groovy
@@ -27,347 +27,347 @@ import static graphql.schema.GraphQLFieldDefinition.newFieldDefinition
 
 class OsgiGraphQLHttpServletSpec extends Specification {
 
-    static class TestQueryProvider implements GraphQLQueryProvider {
-
-        @Override
-        Collection<GraphQLFieldDefinition> getQueries() {
-            List<GraphQLFieldDefinition> fieldDefinitions = new ArrayList<>()
-            fieldDefinitions.add(newFieldDefinition()
-                    .name("query")
-                    .type(new GraphQLAnnotations().object(Query.class))
-                    .staticValue(new Query())
-                    .build())
-            return fieldDefinitions
-        }
-
-        @GraphQLName("query")
-        static class Query {
-            @GraphQLField
-            public String field
-        }
-
-    }
-
-    def "query provider adds query objects"() {
-        setup:
-        OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
-        TestQueryProvider queryProvider = new TestQueryProvider()
-        servlet.bindQueryProvider(queryProvider)
-        GraphQLFieldDefinition query
-
-        when:
-        query = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getQueryType().getFieldDefinition("query")
-        then:
-        query.getType().name == "query"
-
-        when:
-        query = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getQueryType().getFieldDefinition("query")
-        then:
-        query.getType().name == "query"
-
-        when:
-        servlet.unbindQueryProvider(queryProvider)
-        then:
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getQueryType().getFieldDefinitions().get(0).name == "_empty"
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getQueryType().getFieldDefinitions().get(0).name == "_empty"
-    }
-
-    static class TestMutationProvider implements GraphQLMutationProvider {
-        @Override
-        Collection<GraphQLFieldDefinition> getMutations() {
-            return Collections.singletonList(newFieldDefinition().name("int").type(GraphQLInt).staticValue(1).build())
-        }
-    }
-
-    def "mutation provider adds mutation objects"() {
-        setup:
-        OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
-        TestMutationProvider mutationProvider = new TestMutationProvider()
-
-        when:
-        servlet.bindMutationProvider(mutationProvider)
-        then:
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getMutationType().getFieldDefinition("int").getType() == GraphQLInt
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getMutationType() == null
-
-        when:
-        servlet.unbindMutationProvider(mutationProvider)
-        then:
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getMutationType() == null
-
-        when:
-        servlet.bindProvider(mutationProvider)
-        then:
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getMutationType().getFieldDefinition("int").getType() == GraphQLInt
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getMutationType() == null
-
-        when:
-        servlet.unbindProvider(mutationProvider)
-        then:
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getMutationType() == null
-    }
-
-    static class TestSubscriptionProvider implements GraphQLSubscriptionProvider {
-        @Override
-        Collection<GraphQLFieldDefinition> getSubscriptions() {
-            return Collections.singletonList(newFieldDefinition().name("subscription").type(new GraphQLAnnotations().object(Subscription.class)).build())
-        }
-
-        @GraphQLName("subscription")
-        static class Subscription {
-            @GraphQLField
-            public String field
-        }
-    }
-
-    def "subscription provider adds subscription objects"() {
-        setup:
-        OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
-        TestSubscriptionProvider subscriptionProvider = new TestSubscriptionProvider()
-        servlet.bindSubscriptionProvider(subscriptionProvider)
-        GraphQLFieldDefinition subscription
-
-        when:
-        subscription = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getSubscriptionType().getFieldDefinition("subscription")
-        then:
-        subscription.getType().getName() == "subscription"
-
-        when:
-        subscription = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getSubscriptionType().getFieldDefinition("subscription")
-        then:
-        subscription.getType().getName() == "subscription"
-
-        when:
-        servlet.unbindSubscriptionProvider(subscriptionProvider)
-        then:
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getSubscriptionType() == null
-
-        when:
-        servlet.bindProvider(subscriptionProvider)
-        then:
-        def subscription2 = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getSubscriptionType().getFieldDefinition("subscription")
-        subscription2.getType().getName() == "subscription"
-
-        when:
-        servlet.unbindProvider(subscriptionProvider)
-        then:
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getSubscriptionType() == null
-    }
-
-    static class TestCodeRegistryProvider implements GraphQLCodeRegistryProvider {
-        @Override
-        GraphQLCodeRegistry getCodeRegistry() {
-            return GraphQLCodeRegistry.newCodeRegistry().typeResolver("Type", { env -> null }).build()
-        }
-    }
-
-    def "code registry provider adds type resolver"() {
-        setup:
-        OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
-        TestCodeRegistryProvider codeRegistryProvider = new TestCodeRegistryProvider()
-
-        when:
-        servlet.bindCodeRegistryProvider(codeRegistryProvider)
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getCodeRegistry().getTypeResolver(GraphQLInterfaceType.newInterface().name("Type").build())
-        then:
-        notThrown AssertException
-
-        when:
-        servlet.unbindCodeRegistryProvider(codeRegistryProvider)
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getCodeRegistry().getTypeResolver(GraphQLInterfaceType.newInterface().name("Type").build())
-        then:
-        thrown AssertException
-
-        when:
-        servlet.bindProvider(codeRegistryProvider)
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getCodeRegistry().getTypeResolver(GraphQLInterfaceType.newInterface().name("Type").build())
-        then:
-        notThrown AssertException
-
-        when:
-        servlet.unbindProvider(codeRegistryProvider)
-        servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getCodeRegistry().getTypeResolver(GraphQLInterfaceType.newInterface().name("Type").build())
-        then:
-        thrown AssertException
-    }
-
-    def "schema update delay throws no exception"() {
-        setup:
-        OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
-        def config = Mock(OsgiGraphQLHttpServlet.Config)
-
-        when:
-        config.schema_update_delay() >> 1
-        servlet.activate(config)
-        servlet.updateSchema()
-        servlet.updateSchema()
-        servlet.deactivate()
-
-        then:
-        noExceptionThrown()
-    }
-
-    def "bind query provider adds query objects"() {
-        setup:
-        def servlet = new OsgiGraphQLHttpServlet()
-        def queryProvider = new TestQueryProvider()
-        def query
-
-        when:
-        servlet.bindProvider(queryProvider)
-        query = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getQueryType().getFieldDefinition("query")
-
-        then:
-        query.getType().name == "query"
-
-        when:
-        query = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getQueryType().getFieldDefinition("query")
-
-        then:
-        query.getType().name == "query"
-
-        when:
-        servlet.unbindProvider(queryProvider)
-        then:
-        null != servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getQueryType().getFieldDefinition("_empty")
-    }
-
-    def "type provider adds types"() {
-        setup:
-        def servlet = new OsgiGraphQLHttpServlet()
-        def typesProvider = Mock(GraphQLTypesProvider)
-        def coercing = Mock(Coercing)
-        typesProvider.types >> [GraphQLScalarType.newScalar().name("Upload").coercing(coercing).build()]
-
-        when:
-        servlet.bindTypesProvider(typesProvider)
-
-        then:
-        def type = servlet.configuration.invocationInputFactory.schemaProvider.schema.getType("Upload")
-        type != null
-        type.name == "Upload"
-        type instanceof GraphQLScalarType
-        def scalarType = (GraphQLScalarType) type
-        scalarType.coercing == coercing
-
-        when:
-        servlet.unbindTypesProvider(typesProvider)
-
-        then:
-        null == servlet.configuration.invocationInputFactory.schemaProvider.schema.getType("Upload")
-
-        when:
-        servlet.bindProvider(typesProvider)
-        then:
-        servlet.configuration.invocationInputFactory.schemaProvider.schema.getType("Upload").name == "Upload"
-
-        when:
-        servlet.unbindProvider(typesProvider)
-        then:
-        null == servlet.configuration.invocationInputFactory.schemaProvider.schema.getType("Upload")
+  static class TestQueryProvider implements GraphQLQueryProvider {
+
+    @Override
+    Collection<GraphQLFieldDefinition> getQueries() {
+      List<GraphQLFieldDefinition> fieldDefinitions = new ArrayList<>()
+      fieldDefinitions.add(newFieldDefinition()
+          .name("query")
+          .type(new GraphQLAnnotations().object(Query.class))
+          .staticValue(new Query())
+          .build())
+      return fieldDefinitions
     }
 
-    def "servlet listener is bound and unbound"() {
-        setup:
-        def servlet = new OsgiGraphQLHttpServlet()
-        def listener = Mock(GraphQLServletListener)
-
-        when:
-        servlet.bindServletListener(listener)
-        then:
-        servlet.configuration.listeners.contains(listener)
-
-        when:
-        servlet.unbindServletListener(listener)
-        then:
-        !servlet.configuration.listeners.contains(listener)
+    @GraphQLName("query")
+    static class Query {
+      @GraphQLField
+      public String field
     }
 
-    def "context builder is bound and unbound"() {
-        setup:
-        def servlet = new OsgiGraphQLHttpServlet()
-        def context = Mock(GraphQLContext)
-        context.getDataLoaderRegistry() >> new DataLoaderRegistry()
-        context.getSubject() >> Optional.empty()
-        def contextBuilder = Mock(GraphQLServletContextBuilder)
-        contextBuilder.build() >> context
-        def request = GraphQLRequest.createIntrospectionRequest()
-
-        when:
-        servlet.setContextBuilder(contextBuilder)
-        then:
-        def invocationInput = servlet.configuration.invocationInputFactory.create(request)
-        invocationInput.executionInput.context == context
-
-        when:
-        servlet.unsetContextBuilder(contextBuilder)
-        then:
-        servlet.configuration.invocationInputFactory.create(request).executionInput.context instanceof DefaultGraphQLContext
+  }
+
+  def "query provider adds query objects"() {
+    setup:
+    OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
+    TestQueryProvider queryProvider = new TestQueryProvider()
+    servlet.bindQueryProvider(queryProvider)
+    GraphQLFieldDefinition query
+
+    when:
+    query = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getQueryType().getFieldDefinition("query")
+    then:
+    query.getType().name == "query"
+
+    when:
+    query = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getQueryType().getFieldDefinition("query")
+    then:
+    query.getType().name == "query"
+
+    when:
+    servlet.unbindQueryProvider(queryProvider)
+    then:
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getQueryType().getFieldDefinitions().get(0).name == "_empty"
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getQueryType().getFieldDefinitions().get(0).name == "_empty"
+  }
+
+  static class TestMutationProvider implements GraphQLMutationProvider {
+    @Override
+    Collection<GraphQLFieldDefinition> getMutations() {
+      return Collections.singletonList(newFieldDefinition().name("int").type(GraphQLInt).staticValue(1).build())
     }
-
-    def "root object builder is bound and unbound"() {
-        setup:
-        def servlet = new OsgiGraphQLHttpServlet()
-        def rootObject = Mock(Object)
-        def rootObjectBuilder = Mock(GraphQLServletRootObjectBuilder)
-        rootObjectBuilder.build() >> rootObject
-        def request = GraphQLRequest.createIntrospectionRequest()
-
-        when:
-        servlet.setRootObjectBuilder(rootObjectBuilder)
-        then:
-        def invocationInput = servlet.configuration.invocationInputFactory.create(request)
-        invocationInput.executionInput.root == rootObject
-
-        when:
-        servlet.unsetRootObjectBuilder(rootObjectBuilder)
-        then:
-        servlet.configuration.invocationInputFactory.create(request).executionInput.root != rootObject
+  }
+
+  def "mutation provider adds mutation objects"() {
+    setup:
+    OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
+    TestMutationProvider mutationProvider = new TestMutationProvider()
+
+    when:
+    servlet.bindMutationProvider(mutationProvider)
+    then:
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getMutationType().getFieldDefinition("int").getType() == GraphQLInt
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getMutationType() == null
+
+    when:
+    servlet.unbindMutationProvider(mutationProvider)
+    then:
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getMutationType() == null
+
+    when:
+    servlet.bindProvider(mutationProvider)
+    then:
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getMutationType().getFieldDefinition("int").getType() == GraphQLInt
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getMutationType() == null
+
+    when:
+    servlet.unbindProvider(mutationProvider)
+    then:
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getMutationType() == null
+  }
+
+  static class TestSubscriptionProvider implements GraphQLSubscriptionProvider {
+    @Override
+    Collection<GraphQLFieldDefinition> getSubscriptions() {
+      return Collections.singletonList(newFieldDefinition().name("subscription").type(new GraphQLAnnotations().object(Subscription.class)).build())
     }
 
-    def "execution strategy is bound and unbound"() {
-        setup:
-        def servlet = new OsgiGraphQLHttpServlet()
-        def executionStrategy = Mock(ExecutionStrategyProvider)
-        def request = GraphQLRequest.createIntrospectionRequest()
-
-        when:
-        servlet.setExecutionStrategyProvider(executionStrategy)
-        def invocationInput = servlet.configuration.invocationInputFactory.create(request)
-        servlet.configuration.graphQLInvoker.query(invocationInput)
-
-        then:
-        1 * executionStrategy.getQueryExecutionStrategy()
-
-        when:
-        servlet.unsetExecutionStrategyProvider(executionStrategy)
-        def invocationInput2 = servlet.configuration.invocationInputFactory.create(request)
-        servlet.configuration.graphQLInvoker.query(invocationInput2)
-
-        then:
-        0 * executionStrategy.getQueryExecutionStrategy()
+    @GraphQLName("subscription")
+    static class Subscription {
+      @GraphQLField
+      public String field
     }
-
-    def "instrumentation provider is bound and unbound"() {
-        setup:
-        def servlet = new OsgiGraphQLHttpServlet()
-        def instrumentation = new SimpleInstrumentation()
-        def instrumentationProvider = Mock(InstrumentationProvider)
-        instrumentationProvider.getInstrumentation() >> instrumentation
-        def request = GraphQLRequest.createIntrospectionRequest()
-        instrumentation.createState(_ as InstrumentationCreateStateParameters) >> Mock(InstrumentationState)
-
-        when:
-        servlet.setInstrumentationProvider(instrumentationProvider)
-        def invocationInput = servlet.configuration.invocationInputFactory.create(request)
-        servlet.configuration.graphQLInvoker.query(invocationInput)
-
-        then:
-        noExceptionThrown()
-
-        when:
-        servlet.unsetInstrumentationProvider(instrumentationProvider)
-        then:
-        noExceptionThrown()
+  }
+
+  def "subscription provider adds subscription objects"() {
+    setup:
+    OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
+    TestSubscriptionProvider subscriptionProvider = new TestSubscriptionProvider()
+    servlet.bindSubscriptionProvider(subscriptionProvider)
+    GraphQLFieldDefinition subscription
+
+    when:
+    subscription = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getSubscriptionType().getFieldDefinition("subscription")
+    then:
+    subscription.getType().getName() == "subscription"
+
+    when:
+    subscription = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getSubscriptionType().getFieldDefinition("subscription")
+    then:
+    subscription.getType().getName() == "subscription"
+
+    when:
+    servlet.unbindSubscriptionProvider(subscriptionProvider)
+    then:
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getSubscriptionType() == null
+
+    when:
+    servlet.bindProvider(subscriptionProvider)
+    then:
+    def subscription2 = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getSubscriptionType().getFieldDefinition("subscription")
+    subscription2.getType().getName() == "subscription"
+
+    when:
+    servlet.unbindProvider(subscriptionProvider)
+    then:
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getSubscriptionType() == null
+  }
+
+  static class TestCodeRegistryProvider implements GraphQLCodeRegistryProvider {
+    @Override
+    GraphQLCodeRegistry getCodeRegistry() {
+      return GraphQLCodeRegistry.newCodeRegistry().typeResolver("Type", { env -> null }).build()
     }
+  }
+
+  def "code registry provider adds type resolver"() {
+    setup:
+    OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
+    TestCodeRegistryProvider codeRegistryProvider = new TestCodeRegistryProvider()
+
+    when:
+    servlet.bindCodeRegistryProvider(codeRegistryProvider)
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getCodeRegistry().getTypeResolver(GraphQLInterfaceType.newInterface().name("Type").build())
+    then:
+    notThrown AssertException
+
+    when:
+    servlet.unbindCodeRegistryProvider(codeRegistryProvider)
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getCodeRegistry().getTypeResolver(GraphQLInterfaceType.newInterface().name("Type").build())
+    then:
+    thrown AssertException
+
+    when:
+    servlet.bindProvider(codeRegistryProvider)
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getCodeRegistry().getTypeResolver(GraphQLInterfaceType.newInterface().name("Type").build())
+    then:
+    notThrown AssertException
+
+    when:
+    servlet.unbindProvider(codeRegistryProvider)
+    servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getCodeRegistry().getTypeResolver(GraphQLInterfaceType.newInterface().name("Type").build())
+    then:
+    thrown AssertException
+  }
+
+  def "schema update delay throws no exception"() {
+    setup:
+    OsgiGraphQLHttpServlet servlet = new OsgiGraphQLHttpServlet()
+    def config = Mock(OsgiGraphQLHttpServlet.Config)
+
+    when:
+    config.schema_update_delay() >> 1
+    servlet.activate(config)
+    servlet.updateSchema()
+    servlet.updateSchema()
+    servlet.deactivate()
+
+    then:
+    noExceptionThrown()
+  }
+
+  def "bind query provider adds query objects"() {
+    setup:
+    def servlet = new OsgiGraphQLHttpServlet()
+    def queryProvider = new TestQueryProvider()
+    def query
+
+    when:
+    servlet.bindProvider(queryProvider)
+    query = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getQueryType().getFieldDefinition("query")
+
+    then:
+    query.getType().name == "query"
+
+    when:
+    query = servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getReadOnlySchema().getQueryType().getFieldDefinition("query")
+
+    then:
+    query.getType().name == "query"
+
+    when:
+    servlet.unbindProvider(queryProvider)
+    then:
+    null != servlet.getConfiguration().getInvocationInputFactory().getSchemaProvider().getSchema().getQueryType().getFieldDefinition("_empty")
+  }
+
+  def "type provider adds types"() {
+    setup:
+    def servlet = new OsgiGraphQLHttpServlet()
+    def typesProvider = Mock(GraphQLTypesProvider)
+    def coercing = Mock(Coercing)
+    typesProvider.types >> [GraphQLScalarType.newScalar().name("Upload").coercing(coercing).build()]
+
+    when:
+    servlet.bindTypesProvider(typesProvider)
+
+    then:
+    def type = servlet.configuration.invocationInputFactory.schemaProvider.schema.getType("Upload")
+    type != null
+    type.name == "Upload"
+    type instanceof GraphQLScalarType
+    def scalarType = (GraphQLScalarType) type
+    scalarType.coercing == coercing
+
+    when:
+    servlet.unbindTypesProvider(typesProvider)
+
+    then:
+    null == servlet.configuration.invocationInputFactory.schemaProvider.schema.getType("Upload")
+
+    when:
+    servlet.bindProvider(typesProvider)
+    then:
+    servlet.configuration.invocationInputFactory.schemaProvider.schema.getType("Upload").name == "Upload"
+
+    when:
+    servlet.unbindProvider(typesProvider)
+    then:
+    null == servlet.configuration.invocationInputFactory.schemaProvider.schema.getType("Upload")
+  }
+
+  def "servlet listener is bound and unbound"() {
+    setup:
+    def servlet = new OsgiGraphQLHttpServlet()
+    def listener = Mock(GraphQLServletListener)
+
+    when:
+    servlet.bindServletListener(listener)
+    then:
+    servlet.configuration.listeners.contains(listener)
+
+    when:
+    servlet.unbindServletListener(listener)
+    then:
+    !servlet.configuration.listeners.contains(listener)
+  }
+
+  def "context builder is bound and unbound"() {
+    setup:
+    def servlet = new OsgiGraphQLHttpServlet()
+    def context = Mock(GraphQLContext)
+    context.getDataLoaderRegistry() >> new DataLoaderRegistry()
+    context.getSubject() >> Optional.empty()
+    def contextBuilder = Mock(GraphQLServletContextBuilder)
+    contextBuilder.build() >> context
+    def request = GraphQLRequest.createIntrospectionRequest()
+
+    when:
+    servlet.setContextBuilder(contextBuilder)
+    then:
+    def invocationInput = servlet.configuration.invocationInputFactory.create(request)
+    invocationInput.executionInput.context == context
+
+    when:
+    servlet.unsetContextBuilder(contextBuilder)
+    then:
+    servlet.configuration.invocationInputFactory.create(request).executionInput.context instanceof DefaultGraphQLContext
+  }
+
+  def "root object builder is bound and unbound"() {
+    setup:
+    def servlet = new OsgiGraphQLHttpServlet()
+    def rootObject = Mock(Object)
+    def rootObjectBuilder = Mock(GraphQLServletRootObjectBuilder)
+    rootObjectBuilder.build() >> rootObject
+    def request = GraphQLRequest.createIntrospectionRequest()
+
+    when:
+    servlet.setRootObjectBuilder(rootObjectBuilder)
+    then:
+    def invocationInput = servlet.configuration.invocationInputFactory.create(request)
+    invocationInput.executionInput.root == rootObject
+
+    when:
+    servlet.unsetRootObjectBuilder(rootObjectBuilder)
+    then:
+    servlet.configuration.invocationInputFactory.create(request).executionInput.root != rootObject
+  }
+
+  def "execution strategy is bound and unbound"() {
+    setup:
+    def servlet = new OsgiGraphQLHttpServlet()
+    def executionStrategy = Mock(ExecutionStrategyProvider)
+    def request = GraphQLRequest.createIntrospectionRequest()
+
+    when:
+    servlet.setExecutionStrategyProvider(executionStrategy)
+    def invocationInput = servlet.configuration.invocationInputFactory.create(request)
+    servlet.configuration.graphQLInvoker.query(invocationInput)
+
+    then:
+    1 * executionStrategy.getQueryExecutionStrategy()
+
+    when:
+    servlet.unsetExecutionStrategyProvider(executionStrategy)
+    def invocationInput2 = servlet.configuration.invocationInputFactory.create(request)
+    servlet.configuration.graphQLInvoker.query(invocationInput2)
+
+    then:
+    0 * executionStrategy.getQueryExecutionStrategy()
+  }
+
+  def "instrumentation provider is bound and unbound"() {
+    setup:
+    def servlet = new OsgiGraphQLHttpServlet()
+    def instrumentation = new SimpleInstrumentation()
+    def instrumentationProvider = Mock(InstrumentationProvider)
+    instrumentationProvider.getInstrumentation() >> instrumentation
+    def request = GraphQLRequest.createIntrospectionRequest()
+    instrumentation.createState(_ as InstrumentationCreateStateParameters) >> Mock(InstrumentationState)
+
+    when:
+    servlet.setInstrumentationProvider(instrumentationProvider)
+    def invocationInput = servlet.configuration.invocationInputFactory.create(request)
+    servlet.configuration.graphQLInvoker.query(invocationInput)
+
+    then:
+    noExceptionThrown()
+
+    when:
+    servlet.unsetInstrumentationProvider(instrumentationProvider)
+    then:
+    noExceptionThrown()
+  }
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/PartIOExceptionTest.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/PartIOExceptionTest.groovy
index 4de3ede9..949d8d55 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/PartIOExceptionTest.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/PartIOExceptionTest.groovy
@@ -4,10 +4,10 @@ import spock.lang.Specification
 
 class PartIOExceptionTest extends Specification {
 
-    def "constructs"() {
-        when:
-        def e = new PartIOException("some message", new IOException())
-        then:
-        e instanceof RuntimeException
-    }
+  def "constructs"() {
+    when:
+    def e = new PartIOException("some message", new IOException())
+    then:
+    e instanceof RuntimeException
+  }
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/RequestTester.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/RequestTester.groovy
new file mode 100644
index 00000000..3de7fd94
--- /dev/null
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/RequestTester.groovy
@@ -0,0 +1,72 @@
+package graphql.kickstart.servlet
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import graphql.execution.reactive.SingleSubscriberPublisher
+import graphql.kickstart.servlet.core.GraphQLServletListener
+import org.springframework.mock.web.MockHttpServletRequest
+import org.springframework.mock.web.MockHttpServletResponse
+import spock.lang.Shared
+
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.atomic.AtomicReference
+
+class RequestTester {
+
+  public static final int STATUS_OK = 200
+  public static final int STATUS_BAD_REQUEST = 400
+  public static final int STATUS_ERROR = 500
+  public static final String CONTENT_TYPE_JSON_UTF8 = 'application/json;charset=UTF-8'
+  public static final String CONTENT_TYPE_SERVER_SENT_EVENTS = 'text/event-stream;charset=UTF-8'
+
+  @Shared
+  ObjectMapper mapper = new ObjectMapper()
+
+  AbstractGraphQLHttpServlet servlet
+  MockHttpServletRequest request
+  MockHttpServletResponse response
+  CountDownLatch subscriptionLatch
+
+  RequestTester(GraphQLServletListener... listeners) {
+    subscriptionLatch = new CountDownLatch(1)
+    servlet = TestUtils.createDefaultServlet(
+        { env -> env.arguments.arg },
+        { env -> env.arguments.arg },
+        { env ->
+          AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+          publisherRef.set(new SingleSubscriberPublisher<String>({
+            SingleSubscriberPublisher<String> publisher = publisherRef.get()
+            publisher.offer("First\n\n" + env.arguments.arg)
+            publisher.offer("Second\n\n" + env.arguments.arg)
+            publisher.noMoreData()
+            subscriptionLatch.countDown()
+          }))
+          return publisherRef.get()
+        },
+        listeners)
+
+    request = new MockHttpServletRequest()
+    request.asyncSupported = true
+    request.method = "GET"
+    response = new MockHttpServletResponse()
+  }
+
+  Map<String, Object> getResponseContent() {
+    mapper.readValue(response.getContentAsByteArray(), Map)
+  }
+
+  def addParameter(String name, String value) {
+    request.addParameter(name, value)
+  }
+
+  def doGet() {
+    servlet.doGet(request, response)
+  }
+
+  def assertThatResponseIsOk() {
+    return response.getStatus() == STATUS_OK
+  }
+
+  def assertThatContentTypeIsJson() {
+    return response.getContentType() == CONTENT_TYPE_JSON_UTF8
+  }
+}
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleAsynchronousQueryResponseWriterTest.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleAsynchronousQueryResponseWriterTest.groovy
index 5a02ecf4..7a452b18 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleAsynchronousQueryResponseWriterTest.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleAsynchronousQueryResponseWriterTest.groovy
@@ -10,25 +10,25 @@ import javax.servlet.http.HttpServletResponse
 
 class SingleAsynchronousQueryResponseWriterTest extends Specification {
 
-    def "result data is no publisher should"() {
-        given:
-        def result = Mock(ExecutionResult)
-        def objectMapper = Mock(GraphQLObjectMapper)
-        def writer = new SingleAsynchronousQueryResponseWriter(result, objectMapper, 100)
-        def request = Mock(HttpServletRequest)
-        def responseWriter = new PrintWriter(new StringWriter())
-        def response = Mock(HttpServletResponse)
-        response.getWriter() >> responseWriter
-        def asyncContext = new MockAsyncContext(request, response)
-        request.getAsyncContext() >> asyncContext
-        request.isAsyncStarted() >> true
-        objectMapper.serializeResultAsJson(result) >> "{ }"
+  def "result data is no publisher should"() {
+    given:
+    def result = Mock(ExecutionResult)
+    def objectMapper = Mock(GraphQLObjectMapper)
+    def writer = new SingleAsynchronousQueryResponseWriter(result, objectMapper, 100)
+    def request = Mock(HttpServletRequest)
+    def responseWriter = new PrintWriter(new StringWriter())
+    def response = Mock(HttpServletResponse)
+    response.getWriter() >> responseWriter
+    def asyncContext = new MockAsyncContext(request, response)
+    request.getAsyncContext() >> asyncContext
+    request.isAsyncStarted() >> true
+    objectMapper.serializeResultAsJson(result) >> "{ }"
 
-        when:
-        writer.write(request, response)
+    when:
+    writer.write(request, response)
 
-        then:
-        noExceptionThrown()
-    }
+    then:
+    noExceptionThrown()
+  }
 
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleQueryResponseWriterTest.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleQueryResponseWriterTest.groovy
index 1b6d9ba4..0bffe1bb 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleQueryResponseWriterTest.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleQueryResponseWriterTest.groovy
@@ -13,27 +13,27 @@ import java.nio.charset.StandardCharsets
 
 class SingleQueryResponseWriterTest extends Specification {
 
-    @Unroll
-    def "should write utf8 results into the response with content #result"() {
-        given:
-        def graphQLObjectMapperMock = GraphQLObjectMapper.newBuilder().withObjectMapperProvider({ new ObjectMapper() }).build()
-        graphQLObjectMapperMock.getJacksonMapper() >> new ObjectMapper()
-
-        def requestMock = Mock(HttpServletRequest)
-        def responseMock = Mock(HttpServletResponse)
-        responseMock.getOutputStream() >> Mock(ServletOutputStream)
-
-        1 * responseMock.setContentLength(expectedContentLenght)
-        1 * responseMock.setCharacterEncoding(StandardCharsets.UTF_8.name())
-        1 * responseMock.getOutputStream().write(expectedResponseContent.getBytes(StandardCharsets.UTF_8))
-
-        expect:
-        def writer = new SingleQueryResponseWriter(new ExecutionResultImpl(result, []), graphQLObjectMapperMock)
-        writer.write(requestMock, responseMock)
-
-        where:
-        result                || expectedContentLenght | expectedResponseContent
-        [testValue: "abcde"]  || 30                    | """{"data":{"testValue":"abcde"}}"""
-        [testValue: "äöüüöß"] || 37                    | """{"data":{"testValue":"äöüüöß"}}"""
-    }
+  @Unroll
+  def "should write utf8 results into the response with content #result"() {
+    given:
+    def graphQLObjectMapperMock = GraphQLObjectMapper.newBuilder().withObjectMapperProvider({ new ObjectMapper() }).build()
+    graphQLObjectMapperMock.getJacksonMapper() >> new ObjectMapper()
+
+    def requestMock = Mock(HttpServletRequest)
+    def responseMock = Mock(HttpServletResponse)
+    responseMock.getOutputStream() >> Mock(ServletOutputStream)
+
+    1 * responseMock.setContentLength(expectedContentLenght)
+    1 * responseMock.setCharacterEncoding(StandardCharsets.UTF_8.name())
+    1 * responseMock.getOutputStream().write(expectedResponseContent.getBytes(StandardCharsets.UTF_8))
+
+    expect:
+    def writer = new SingleQueryResponseWriter(new ExecutionResultImpl(result, []), graphQLObjectMapperMock)
+    writer.write(requestMock, responseMock)
+
+    where:
+    result                || expectedContentLenght | expectedResponseContent
+    [testValue: "abcde"]  || 30                    | """{"data":{"testValue":"abcde"}}"""
+    [testValue: "äöüüöß"] || 37                    | """{"data":{"testValue":"äöüüöß"}}"""
+  }
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestGraphQLErrorException.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestGraphQLErrorException.groovy
index f41c9fad..0050fa70 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestGraphQLErrorException.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestGraphQLErrorException.groovy
@@ -9,24 +9,24 @@ import graphql.language.SourceLocation
  */
 class TestGraphQLErrorException extends RuntimeException implements GraphQLError {
 
-    public TestGraphQLErrorException(String message) {
-        super(message);
-    }
+  TestGraphQLErrorException(String message) {
+    super(message)
+  }
 
-    @Override
-    public Map<String, Object> getExtensions() {
-        Map<String, Object> customAttributes = new LinkedHashMap<>();
-        customAttributes.put("foo", "bar");
-        return customAttributes;
-    }
+  @Override
+  Map<String, Object> getExtensions() {
+    Map<String, Object> customAttributes = new LinkedHashMap<>()
+    customAttributes.put("foo", "bar")
+    return customAttributes
+  }
 
-    @Override
-    List<SourceLocation> getLocations() {
-        return null
-    }
+  @Override
+  List<SourceLocation> getLocations() {
+    return null
+  }
 
-    @Override
-    ErrorType getErrorType() {
-        return ErrorType.ValidationError;
-    }
+  @Override
+  ErrorType getErrorType() {
+    return ErrorType.ValidationError
+  }
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestMultipartPart.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestMultipartPart.groovy
index 0ae6f3b3..96cc4062 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestMultipartPart.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestMultipartPart.groovy
@@ -7,68 +7,68 @@ import javax.servlet.http.Part
  */
 class TestMultipartContentBuilder {
 
-    static Part createPart(String name, String part) {
-        return new MockPart(name, part);
+  static Part createPart(String name, String part) {
+    return new MockPart(name, part)
+  }
+
+  static class MockPart implements Part {
+    final String name
+    final String content
+
+    MockPart(String name, String content) {
+      this.name = name
+      this.content = content
+    }
+
+    @Override
+    InputStream getInputStream() throws IOException {
+      return new ByteArrayInputStream(content.getBytes())
+    }
+
+    @Override
+    String getContentType() {
+      return null
+    }
+
+    @Override
+    String getName() {
+      return name
+    }
+
+    @Override
+    String getSubmittedFileName() {
+      return name
+    }
+
+    @Override
+    long getSize() {
+      return content.getBytes().length
+    }
+
+    @Override
+    void write(String fileName) throws IOException {
+      throw new IllegalArgumentException("Not supported")
+    }
+
+    @Override
+    void delete() throws IOException {
+      throw new IllegalArgumentException("Not supported")
+    }
+
+    @Override
+    String getHeader(String name) {
+      return null
+    }
+
+    @Override
+    Collection<String> getHeaders(String name) {
+      return Collections.emptyList()
     }
 
-    static class MockPart implements Part {
-        final String name
-        final String content
-
-        MockPart(String name, String content) {
-            this.name = name
-            this.content = content
-        }
-
-        @Override
-        InputStream getInputStream() throws IOException {
-            return new ByteArrayInputStream(content.getBytes())
-        }
-
-        @Override
-        String getContentType() {
-            return null
-        }
-
-        @Override
-        String getName() {
-            return name
-        }
-
-        @Override
-        String getSubmittedFileName() {
-            return name
-        }
-
-        @Override
-        long getSize() {
-            return content.getBytes().length
-        }
-
-        @Override
-        void write(String fileName) throws IOException {
-            throw new IllegalArgumentException("Not supported")
-        }
-
-        @Override
-        void delete() throws IOException {
-            throw new IllegalArgumentException("Not supported")
-        }
-
-        @Override
-        String getHeader(String name) {
-            return null
-        }
-
-        @Override
-        Collection<String> getHeaders(String name) {
-            return Collections.emptyList()
-        }
-
-        @Override
-        Collection<String> getHeaderNames() {
-            return Collections.emptyList()
-        }
+    @Override
+    Collection<String> getHeaderNames() {
+      return Collections.emptyList()
     }
+  }
 
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestUtils.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestUtils.groovy
index c88ab6fb..c15b7ff0 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestUtils.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestUtils.groovy
@@ -7,6 +7,7 @@ import graphql.execution.reactive.SingleSubscriberPublisher
 import graphql.kickstart.execution.context.ContextSetting
 import graphql.kickstart.servlet.apollo.ApolloScalars
 import graphql.kickstart.servlet.context.GraphQLServletContextBuilder
+import graphql.kickstart.servlet.core.GraphQLServletListener
 import graphql.kickstart.servlet.input.BatchInputPreProcessor
 import graphql.schema.*
 import graphql.schema.idl.RuntimeWiring
@@ -19,188 +20,203 @@ import java.util.concurrent.atomic.AtomicReference
 
 class TestUtils {
 
-    static def createDefaultServlet(DataFetcher queryDataFetcher = { env -> env.arguments.arg },
-                                    DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
-                                    DataFetcher subscriptionDataFetcher = { env ->
-                                        AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
-                                        publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
-                                            publisherRef.get().offer(env.arguments.arg)
-                                            publisherRef.get().noMoreData()
-                                        }))
-                                        return publisherRef.get()
-                                    }) {
-        createServlet(queryDataFetcher, mutationDataFetcher, subscriptionDataFetcher, null)
-    }
+  static def createDefaultServlet(
+      DataFetcher queryDataFetcher = { env -> env.arguments.arg },
+      DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
+      DataFetcher subscriptionDataFetcher = { env ->
+        AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+        publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
+          publisherRef.get().offer(env.arguments.arg)
+          publisherRef.get().noMoreData()
+        }))
+        return publisherRef.get()
+      },
+      GraphQLServletListener... listeners) {
+    createServlet(queryDataFetcher, mutationDataFetcher, subscriptionDataFetcher, null, listeners)
+  }
 
-    static def createBatchCustomizedServlet(DataFetcher queryDataFetcher = { env -> env.arguments.arg },
-                                            DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
-                                            DataFetcher subscriptionDataFetcher = { env ->
-                                                AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
-                                                publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
-                                                    publisherRef.get().offer(env.arguments.arg)
-                                                    publisherRef.get().noMoreData()
-                                                }))
-                                                return publisherRef.get()
-                                            }) {
-        createServlet(queryDataFetcher, mutationDataFetcher, subscriptionDataFetcher, createBatchExecutionHandler())
-    }
+  static def createBatchCustomizedServlet(
+      DataFetcher queryDataFetcher = { env -> env.arguments.arg },
+      DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
+      DataFetcher subscriptionDataFetcher = { env ->
+        AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+        publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
+          publisherRef.get().offer(env.arguments.arg)
+          publisherRef.get().noMoreData()
+        }))
+        return publisherRef.get()
+      }) {
+    createServlet(queryDataFetcher, mutationDataFetcher, subscriptionDataFetcher, createBatchExecutionHandler())
+  }
 
-    static def createDataLoadingServlet(DataFetcher queryDataFetcher = { env -> env.arguments.arg },
-                                        DataFetcher fieldDataFetcher = { env -> env.arguments.arg },
-                                        DataFetcher otherDataFetcher,
-                                        ContextSetting contextSetting, GraphQLServletContextBuilder contextBuilder) {
-        GraphQLSchema schema = createGraphQlSchemaWithTwoLevels(queryDataFetcher, fieldDataFetcher, otherDataFetcher)
-        GraphQLHttpServlet servlet = GraphQLHttpServlet.with(GraphQLConfiguration
-                .with(schema)
-                .with(contextSetting)
-                .with(contextBuilder)
-                .build())
-        servlet.init(null)
-        return servlet
-    }
+  static def createDataLoadingServlet(
+      DataFetcher queryDataFetcher = { env -> env.arguments.arg },
+      DataFetcher fieldDataFetcher = { env -> env.arguments.arg },
+      DataFetcher otherDataFetcher,
+      ContextSetting contextSetting, GraphQLServletContextBuilder contextBuilder) {
+    GraphQLSchema schema = createGraphQlSchemaWithTwoLevels(queryDataFetcher, fieldDataFetcher, otherDataFetcher)
+    GraphQLHttpServlet servlet = GraphQLHttpServlet.with(GraphQLConfiguration
+        .with(schema)
+        .with(contextSetting)
+        .with(contextBuilder)
+        .build())
+    servlet.init(null)
+    return servlet
+  }
 
-    private static def createServlet(DataFetcher queryDataFetcher = { env -> env.arguments.arg },
-                                     DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
-                                     DataFetcher subscriptionDataFetcher = { env ->
-                                         AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
-                                         publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
-                                             publisherRef.get().offer(env.arguments.arg)
-                                             publisherRef.get().noMoreData()
-                                         }))
-                                         return publisherRef.get()
-                                     }, BatchInputPreProcessor batchHandler) {
-        GraphQLHttpServlet servlet = GraphQLHttpServlet.with(
-                graphQLConfiguration(createGraphQlSchema(queryDataFetcher, mutationDataFetcher, subscriptionDataFetcher),
-                        batchHandler))
-        servlet.init(null)
-        return servlet
-    }
+  private static def createServlet(
+      DataFetcher queryDataFetcher = { env -> env.arguments.arg },
+      DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
+      DataFetcher subscriptionDataFetcher = { env ->
+        AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+        publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
+          publisherRef.get().offer(env.arguments.arg)
+          publisherRef.get().noMoreData()
+        }))
+        return publisherRef.get()
+      },
+      BatchInputPreProcessor batchHandler,
+      GraphQLServletListener... listeners) {
+    GraphQLHttpServlet servlet = GraphQLHttpServlet.with(
+        graphQLConfiguration(
+            createGraphQlSchema(queryDataFetcher, mutationDataFetcher, subscriptionDataFetcher),
+            batchHandler,
+            listeners
+        )
+    )
+    servlet.init(null)
+    return servlet
+  }
 
-    static def graphQLConfiguration(GraphQLSchema schema, BatchInputPreProcessor batchInputPreProcessor) {
-        def configBuilder = GraphQLConfiguration.with(schema)
-        if (batchInputPreProcessor != null) {
-            configBuilder.with(batchInputPreProcessor)
-        }
-        configBuilder.build()
+  static def graphQLConfiguration(GraphQLSchema schema, BatchInputPreProcessor batchInputPreProcessor, GraphQLServletListener... listeners) {
+    def configBuilder = GraphQLConfiguration.with(schema)
+    if (batchInputPreProcessor != null) {
+      configBuilder.with(batchInputPreProcessor)
     }
-
-    static def createBatchExecutionHandler() {
-        new TestBatchInputPreProcessor()
+    if (listeners != null) {
+      configBuilder.with(Arrays.asList(listeners))
     }
+    configBuilder.build()
+  }
 
-    static def createGraphQlSchema(DataFetcher queryDataFetcher = { env -> env.arguments.arg },
-                                   DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
-                                   DataFetcher subscriptionDataFetcher = { env ->
-                                       AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
-                                       publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
-                                           publisherRef.get().offer(env.arguments.arg)
-                                           publisherRef.get().noMoreData()
-                                       }))
-                                       return publisherRef.get()
-                                   }) {
-        GraphQLObjectType query = GraphQLObjectType.newObject()
-                .name("Query")
-                .field { GraphQLFieldDefinition.Builder field ->
-                    field.name("echo")
-                    field.type(Scalars.GraphQLString)
-                    field.argument { argument ->
-                        argument.name("arg")
-                        argument.type(Scalars.GraphQLString)
-                    }
-                    field.dataFetcher(queryDataFetcher)
-                }
-                .field { GraphQLFieldDefinition.Builder field ->
-                    field.name("object")
-                    field.type(
-                            GraphQLObjectType.newObject()
-                                    .name("NestedObject")
-                                    .field { nested ->
-                                        nested.name("a")
-                                        nested.type(Scalars.GraphQLString)
-                                        nested.argument { argument ->
-                                            argument.name("arg")
-                                            argument.type(Scalars.GraphQLString)
-                                        }
-                                        nested.dataFetcher(queryDataFetcher)
-                                    }
-                                    .field { nested ->
-                                        nested.name("b")
-                                        nested.type(Scalars.GraphQLString)
-                                        nested.argument { argument ->
-                                            argument.name("arg")
-                                            argument.type(Scalars.GraphQLString)
-                                        }
-                                        nested.dataFetcher(queryDataFetcher)
-                                    }
-                    )
-                    field.dataFetcher(new StaticDataFetcher([:]))
-                }
-                .field { GraphQLFieldDefinition.Builder field ->
-                    field.name("returnsNullIncorrectly")
-                    field.type(new GraphQLNonNull(Scalars.GraphQLString))
-                    field.dataFetcher({ env -> null })
-                }
-                .build()
-
-        GraphQLObjectType mutation = GraphQLObjectType.newObject()
-                .name("Mutation")
-                .field { field ->
-                    field.name("echo")
-                    field.type(Scalars.GraphQLString)
-                    field.argument { argument ->
-                        argument.name("arg")
-                        argument.type(Scalars.GraphQLString)
-                    }
-                    field.dataFetcher(mutationDataFetcher)
-                }
-                .field { field ->
-                    field.name("echoFile")
-                    field.type(Scalars.GraphQLString)
-                    field.argument { argument ->
-                        argument.name("file")
-                        argument.type(ApolloScalars.Upload)
-                    }
-                    field.dataFetcher({ env -> new String(ByteStreams.toByteArray(env.arguments.file.getInputStream())) })
-                }
-                .field { field ->
-                    field.name("echoFiles")
-                    field.type(GraphQLList.list(Scalars.GraphQLString))
-                    field.argument { argument ->
-                        argument.name("files")
-                        argument.type(GraphQLList.list(GraphQLNonNull.nonNull(ApolloScalars.Upload)))
+  static def createBatchExecutionHandler() {
+    new TestBatchInputPreProcessor()
+  }
+
+  static def createGraphQlSchema(
+      DataFetcher queryDataFetcher = { env -> env.arguments.arg },
+      DataFetcher mutationDataFetcher = { env -> env.arguments.arg },
+      DataFetcher subscriptionDataFetcher = { env ->
+        AtomicReference<SingleSubscriberPublisher<String>> publisherRef = new AtomicReference<>()
+        publisherRef.set(new SingleSubscriberPublisher<>({ subscription ->
+          publisherRef.get().offer(env.arguments.arg)
+          publisherRef.get().noMoreData()
+        }))
+        return publisherRef.get()
+      }) {
+    GraphQLObjectType query = GraphQLObjectType.newObject()
+        .name("Query")
+        .field { GraphQLFieldDefinition.Builder field ->
+          field.name("echo")
+          field.type(Scalars.GraphQLString)
+          field.argument { argument ->
+            argument.name("arg")
+            argument.type(Scalars.GraphQLString)
+          }
+          field.dataFetcher(queryDataFetcher)
+        }
+        .field { GraphQLFieldDefinition.Builder field ->
+          field.name("object")
+          field.type(
+              GraphQLObjectType.newObject()
+                  .name("NestedObject")
+                  .field { nested ->
+                    nested.name("a")
+                    nested.type(Scalars.GraphQLString)
+                    nested.argument { argument ->
+                      argument.name("arg")
+                      argument.type(Scalars.GraphQLString)
                     }
-                    field.dataFetcher({ env ->
-                        env.arguments.files.collect {
-                            new String(ByteStreams.toByteArray(it.getInputStream()))
-                        }
-                    })
-                }
-                .build()
-
-        GraphQLObjectType subscription = GraphQLObjectType.newObject()
-                .name("Subscription")
-                .field { field ->
-                    field.name("echo")
-                    field.type(Scalars.GraphQLString)
-                    field.argument { argument ->
-                        argument.name("arg")
-                        argument.type(Scalars.GraphQLString)
+                    nested.dataFetcher(queryDataFetcher)
+                  }
+                  .field { nested ->
+                    nested.name("b")
+                    nested.type(Scalars.GraphQLString)
+                    nested.argument { argument ->
+                      argument.name("arg")
+                      argument.type(Scalars.GraphQLString)
                     }
-                    field.dataFetcher(subscriptionDataFetcher)
-                }
-                .build()
+                    nested.dataFetcher(queryDataFetcher)
+                  }
+          )
+          field.dataFetcher(new StaticDataFetcher([:]))
+        }
+        .field { GraphQLFieldDefinition.Builder field ->
+          field.name("returnsNullIncorrectly")
+          field.type(new GraphQLNonNull(Scalars.GraphQLString))
+          field.dataFetcher({ env -> null })
+        }
+        .build()
 
+    GraphQLObjectType mutation = GraphQLObjectType.newObject()
+        .name("Mutation")
+        .field { field ->
+          field.name("echo")
+          field.type(Scalars.GraphQLString)
+          field.argument { argument ->
+            argument.name("arg")
+            argument.type(Scalars.GraphQLString)
+          }
+          field.dataFetcher(mutationDataFetcher)
+        }
+        .field { field ->
+          field.name("echoFile")
+          field.type(Scalars.GraphQLString)
+          field.argument { argument ->
+            argument.name("file")
+            argument.type(ApolloScalars.Upload)
+          }
+          field.dataFetcher({ env -> new String(ByteStreams.toByteArray(env.arguments.file.getInputStream())) })
+        }
+        .field { field ->
+          field.name("echoFiles")
+          field.type(GraphQLList.list(Scalars.GraphQLString))
+          field.argument { argument ->
+            argument.name("files")
+            argument.type(GraphQLList.list(GraphQLNonNull.nonNull(ApolloScalars.Upload)))
+          }
+          field.dataFetcher({ env ->
+            env.arguments.files.collect {
+              new String(ByteStreams.toByteArray(it.getInputStream()))
+            }
+          })
+        }
+        .build()
 
-        return GraphQLSchema.newSchema()
-                .query(query)
-                .mutation(mutation)
-                .subscription(subscription)
-                .additionalType(ApolloScalars.Upload)
-                .build()
-    }
+    GraphQLObjectType subscription = GraphQLObjectType.newObject()
+        .name("Subscription")
+        .field { field ->
+          field.name("echo")
+          field.type(Scalars.GraphQLString)
+          field.argument { argument ->
+            argument.name("arg")
+            argument.type(Scalars.GraphQLString)
+          }
+          field.dataFetcher(subscriptionDataFetcher)
+        }
+        .build()
 
-    static def createGraphQlSchemaWithTwoLevels(DataFetcher queryDataFetcher, DataFetcher fieldDataFetcher, DataFetcher otherQueryFetcher) {
-        String sdl = """schema {
+
+    return GraphQLSchema.newSchema()
+        .query(query)
+        .mutation(mutation)
+        .subscription(subscription)
+        .additionalType(ApolloScalars.Upload)
+        .build()
+  }
+
+  static def createGraphQlSchemaWithTwoLevels(DataFetcher queryDataFetcher, DataFetcher fieldDataFetcher, DataFetcher otherQueryFetcher) {
+    String sdl = """schema {
                         query: Query
                     }
 
@@ -222,22 +238,22 @@ class TestUtils {
                     }
                     """
 
-        def wiring = RuntimeWiring.newRuntimeWiring()
-                .type(TypeRuntimeWiring.newTypeWiring("Query").dataFetcher("query", { env -> env.arguments.arg })
-                        .dataFetcher("queryTwo", { env -> env.arguments.arg }))
-                .type(TypeRuntimeWiring.newTypeWiring("QueryEcho").dataFetcher("echo", queryDataFetcher))
-                .type(TypeRuntimeWiring.newTypeWiring("FieldEcho").dataFetcher("echo", fieldDataFetcher))
-                .type(TypeRuntimeWiring.newTypeWiring("OtherQueryEcho").dataFetcher("echo", otherQueryFetcher))
-                .build()
-
-
-        try {
-            def registry = new SchemaParser().parse(new StringReader(sdl))
-            def options = SchemaGenerator.Options.defaultOptions()
-            return new SchemaGenerator().makeExecutableSchema(options, registry, wiring)
-        } catch (SchemaProblem e) {
-            assert false: "The schema could not be compiled : ${e}"
-            return null
-        }
+    def wiring = RuntimeWiring.newRuntimeWiring()
+        .type(TypeRuntimeWiring.newTypeWiring("Query").dataFetcher("query", { env -> env.arguments.arg })
+            .dataFetcher("queryTwo", { env -> env.arguments.arg }))
+        .type(TypeRuntimeWiring.newTypeWiring("QueryEcho").dataFetcher("echo", queryDataFetcher))
+        .type(TypeRuntimeWiring.newTypeWiring("FieldEcho").dataFetcher("echo", fieldDataFetcher))
+        .type(TypeRuntimeWiring.newTypeWiring("OtherQueryEcho").dataFetcher("echo", otherQueryFetcher))
+        .build()
+
+
+    try {
+      def registry = new SchemaParser().parse(new StringReader(sdl))
+      def options = SchemaGenerator.Options.defaultOptions()
+      return new SchemaGenerator().makeExecutableSchema(options, registry, wiring)
+    } catch (SchemaProblem e) {
+      assert false: "The schema could not be compiled : ${e}"
+      return null
     }
+  }
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/cache/CacheReaderTest.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/cache/CacheReaderTest.groovy
index 48809d1c..3d8f5601 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/cache/CacheReaderTest.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/cache/CacheReaderTest.groovy
@@ -9,76 +9,76 @@ import javax.servlet.http.HttpServletResponse
 
 class CacheReaderTest extends Specification {
 
-    def cacheManager
-    def invocationInput
-    def request
-    def response
-    def cacheReader
-    def cachedResponse
-
-    def setup() {
-        cacheManager = Mock(GraphQLResponseCacheManager)
-        invocationInput = Mock(GraphQLInvocationInput)
-        request = Mock(HttpServletRequest)
-        response = Mock(HttpServletResponse)
-        cacheReader = new CacheReader()
-        cachedResponse = Mock(CachedResponse)
-    }
-
-    def "should return false if no cached response"() {
-        given:
-        cacheManager.get(request, invocationInput) >> null
-
-        when:
-        def result = cacheReader.responseFromCache(invocationInput, request, response, cacheManager)
-
-        then:
-        !result
-    }
-
-    def "should send error response if cached response is error"() {
-        given:
-        cachedResponse.isError() >> true
-        cachedResponse.getErrorStatusCode() >> 10
-        cachedResponse.getErrorMessage() >> "some error"
-        cacheManager.get(request, invocationInput) >> cachedResponse
-
-        when:
-        def result = cacheReader.responseFromCache(invocationInput, request, response, cacheManager)
-
-        then:
-        result
-        1 * response.sendError(10, "some error")
-    }
-
-    def "should send success response if cached response is ok"() {
-        given:
-        def outputStream = Mock(ServletOutputStream)
-        cachedResponse.isError() >> false
-        cachedResponse.getContentBytes() >> [ 00, 01, 02 ]
-        response.getOutputStream() >> outputStream
-        cacheManager.get(request, invocationInput) >> cachedResponse
-
-        when:
-        def result = cacheReader.responseFromCache(invocationInput, request, response, cacheManager)
-
-        then:
-        result
-        1 * response.setContentType("application/json;charset=UTF-8")
-        1 * response.setStatus(200)
-        1 * response.setCharacterEncoding("UTF-8")
-        1 * response.setContentLength(3)
-        1 * outputStream.write([ 00, 01, 02 ])
-    }
-
-    def "should return false if exception is thrown"() {
-        given:
-        cacheManager.get(request, invocationInput) >> {throw new RuntimeException()}
-
-        when:
-        def result = cacheReader.responseFromCache(invocationInput, request, response, cacheManager)
-
-        then:
-        !result
-    }
+  def cacheManager
+  def invocationInput
+  def request
+  def response
+  def cacheReader
+  def cachedResponse
+
+  def setup() {
+    cacheManager = Mock(GraphQLResponseCacheManager)
+    invocationInput = Mock(GraphQLInvocationInput)
+    request = Mock(HttpServletRequest)
+    response = Mock(HttpServletResponse)
+    cacheReader = new CacheReader()
+    cachedResponse = Mock(CachedResponse)
+  }
+
+  def "should return false if no cached response"() {
+    given:
+    cacheManager.get(request, invocationInput) >> null
+
+    when:
+    def result = cacheReader.responseFromCache(invocationInput, request, response, cacheManager)
+
+    then:
+    !result
+  }
+
+  def "should send error response if cached response is error"() {
+    given:
+    cachedResponse.isError() >> true
+    cachedResponse.getErrorStatusCode() >> 10
+    cachedResponse.getErrorMessage() >> "some error"
+    cacheManager.get(request, invocationInput) >> cachedResponse
+
+    when:
+    def result = cacheReader.responseFromCache(invocationInput, request, response, cacheManager)
+
+    then:
+    result
+    1 * response.sendError(10, "some error")
+  }
+
+  def "should send success response if cached response is ok"() {
+    given:
+    def outputStream = Mock(ServletOutputStream)
+    cachedResponse.isError() >> false
+    cachedResponse.getContentBytes() >> [00, 01, 02]
+    response.getOutputStream() >> outputStream
+    cacheManager.get(request, invocationInput) >> cachedResponse
+
+    when:
+    def result = cacheReader.responseFromCache(invocationInput, request, response, cacheManager)
+
+    then:
+    result
+    1 * response.setContentType("application/json;charset=UTF-8")
+    1 * response.setStatus(200)
+    1 * response.setCharacterEncoding("UTF-8")
+    1 * response.setContentLength(3)
+    1 * outputStream.write([00, 01, 02])
+  }
+
+  def "should return false if exception is thrown"() {
+    given:
+    cacheManager.get(request, invocationInput) >> { throw new RuntimeException() }
+
+    when:
+    def result = cacheReader.responseFromCache(invocationInput, request, response, cacheManager)
+
+    then:
+    !result
+  }
 }
diff --git a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/cache/CachingHttpRequestInvokerTest.groovy b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/cache/CachingHttpRequestInvokerTest.groovy
index b996dd0f..790d8591 100644
--- a/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/cache/CachingHttpRequestInvokerTest.groovy
+++ b/graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/cache/CachingHttpRequestInvokerTest.groovy
@@ -1,79 +1,86 @@
 package graphql.kickstart.servlet.cache
 
-import graphql.kickstart.execution.input.GraphQLInvocationInput
+import graphql.kickstart.execution.GraphQLInvoker
+import graphql.kickstart.execution.GraphQLQueryResult
+import graphql.kickstart.execution.input.GraphQLSingleInvocationInput
 import graphql.kickstart.servlet.GraphQLConfiguration
 import graphql.kickstart.servlet.HttpRequestInvoker
 import spock.lang.Specification
 
 import javax.servlet.http.HttpServletRequest
 import javax.servlet.http.HttpServletResponse
+import java.util.concurrent.CompletableFuture
 
 class CachingHttpRequestInvokerTest extends Specification {
 
-    def cacheReaderMock
-    def cachingInvoker
-    def invocationInputMock
-    def requestMock
-    def responseMock
-    def responseCacheManagerMock
-    def httpRequestInvokerMock
-    def configuration
-
-    def setup() {
-        cacheReaderMock = Mock(CacheReader)
-        invocationInputMock = Mock(GraphQLInvocationInput)
-        requestMock = Mock(HttpServletRequest)
-        responseMock = Mock(HttpServletResponse)
-        responseCacheManagerMock = Mock(GraphQLResponseCacheManager)
-        configuration = Mock(GraphQLConfiguration)
-        httpRequestInvokerMock = Mock(HttpRequestInvoker)
-        cachingInvoker = new CachingHttpRequestInvoker(configuration, httpRequestInvokerMock, cacheReaderMock)
-
-        configuration.getResponseCacheManager() >> responseCacheManagerMock
-    }
-
-    def "should execute regular invoker if cache not exists"() {
-        given:
-        cacheReaderMock.responseFromCache(invocationInputMock, requestMock, responseMock, responseCacheManagerMock) >> false
-
-        when:
-        cachingInvoker.execute(invocationInputMock, requestMock, responseMock)
-
-        then:
-        1 * httpRequestInvokerMock.execute(invocationInputMock, requestMock, responseMock)
-    }
-
-    def "should not execute regular invoker if cache exists"() {
-        given:
-        cacheReaderMock.responseFromCache(invocationInputMock, requestMock, responseMock, responseCacheManagerMock) >> true
-
-        when:
-        cachingInvoker.execute(invocationInputMock, requestMock, responseMock)
-
-        then:
-        0 * httpRequestInvokerMock.execute(invocationInputMock, requestMock, responseMock)
-    }
-
-    def "should return bad request response when ioexception"() {
-        given:
-        cacheReaderMock.responseFromCache(invocationInputMock, requestMock, responseMock, responseCacheManagerMock) >> {throw new IOException()}
-
-        when:
-        cachingInvoker.execute(invocationInputMock, requestMock, responseMock)
-
-        then:
-        1 * responseMock.setStatus(400)
-    }
-
-    def "should initialize completely when using single param constructor"() {
-        given:
-        def invoker = new CachingHttpRequestInvoker(configuration)
-
-        when:
-        invoker.execute(invocationInputMock, requestMock, responseMock)
-
-        then:
-        noExceptionThrown()
-    }
+  def cacheReaderMock
+  def cachingInvoker
+  def invocationInputMock
+  def requestMock
+  def responseMock
+  def responseCacheManagerMock
+  def httpRequestInvokerMock
+  def graphqlInvoker
+  def configuration
+
+  def setup() {
+    cacheReaderMock = Mock(CacheReader)
+    invocationInputMock = Mock(GraphQLSingleInvocationInput)
+    requestMock = Mock(HttpServletRequest)
+    responseMock = Mock(HttpServletResponse)
+    responseCacheManagerMock = Mock(GraphQLResponseCacheManager)
+    configuration = Mock(GraphQLConfiguration)
+    httpRequestInvokerMock = Mock(HttpRequestInvoker)
+    graphqlInvoker = Mock(GraphQLInvoker)
+    cachingInvoker = new CachingHttpRequestInvoker(configuration, httpRequestInvokerMock, cacheReaderMock)
+
+    configuration.getResponseCacheManager() >> responseCacheManagerMock
+    configuration.getGraphQLInvoker() >> graphqlInvoker
+    graphqlInvoker.queryAsync(invocationInputMock) >> CompletableFuture.completedFuture(Mock(GraphQLQueryResult))
+  }
+
+  def "should execute regular invoker if cache not exists"() {
+    given:
+    cacheReaderMock.responseFromCache(invocationInputMock, requestMock, responseMock, responseCacheManagerMock) >> false
+
+    when:
+    cachingInvoker.execute(invocationInputMock, requestMock, responseMock)
+
+    then:
+    1 * httpRequestInvokerMock.execute(invocationInputMock, requestMock, responseMock)
+  }
+
+  def "should not execute regular invoker if cache exists"() {
+    given:
+    cacheReaderMock.responseFromCache(invocationInputMock, requestMock, responseMock, responseCacheManagerMock) >> true
+
+    when:
+    cachingInvoker.execute(invocationInputMock, requestMock, responseMock)
+
+    then:
+    0 * httpRequestInvokerMock.execute(invocationInputMock, requestMock, responseMock)
+  }
+
+  def "should return bad request response when ioexception"() {
+    given:
+    cacheReaderMock.responseFromCache(invocationInputMock, requestMock, responseMock, responseCacheManagerMock) >> { throw new IOException() }
+
+    when:
+    cachingInvoker.execute(invocationInputMock, requestMock, responseMock)
+
+    then:
+    1 * responseMock.setStatus(400)
+  }
+
+  def "should initialize completely when using single param constructor"() {
+    given:
+    def invoker = new CachingHttpRequestInvoker(configuration)
+
+    when:
+    invoker.execute(invocationInputMock, requestMock, responseMock)
+
+    then:
+    noExceptionThrown()
+  }
 
 }