#557 added support for response delay when response is dynamically created

Author: jamesdbloom

mockserver-core/src/main/java/org/mockserver/mock/action/ActionHandler.java

@@ -89,101 +89,91 @@ public void processAction(final HttpRequest request, final ResponseWriter respon
             httpStateHandler.log(new ExpectationMatchLogEntry(request, expectation));
             switch (action.getType()) {
                 case RESPONSE: {
-                    final HttpResponse httpResponse = (HttpResponse) action;
-                    scheduler.schedule(new Runnable() {
+                    scheduler.submit(new Runnable() {
                         public void run() {
-                            HttpResponse response = httpResponseActionHandler.handle(httpResponse);
-                            writeResponseActionResponse(response, responseWriter, request, action);
+                            final HttpResponse response = httpResponseActionHandler.handle((HttpResponse) action);
+                            writeResponseActionResponse(response, responseWriter, request, action, synchronous);
                         }
-                    }, httpResponse.getDelay(), synchronous);
+                    }, synchronous);
                     break;
                 }
                 case RESPONSE_TEMPLATE: {
-                    final HttpTemplate httpTemplate = (HttpTemplate) action;
-                    scheduler.schedule(new Runnable() {
+                    scheduler.submit(new Runnable() {
                         public void run() {
-                            HttpResponse response = httpResponseTemplateActionHandler.handle(httpTemplate, request);
-                            writeResponseActionResponse(response, responseWriter, request, action);
+                            final HttpResponse response = httpResponseTemplateActionHandler.handle((HttpTemplate) action, request);
+                            writeResponseActionResponse(response, responseWriter, request, action, synchronous);
                         }
-                    }, httpTemplate.getDelay(), synchronous);
+                    }, synchronous);
                     break;
                 }
                 case RESPONSE_CLASS_CALLBACK: {
-                    final HttpClassCallback classCallback = (HttpClassCallback) action;
                     scheduler.submit(new Runnable() {
                         public void run() {
-                            HttpResponse response = httpResponseClassCallbackActionHandler.handle(classCallback, request);
-                            writeResponseActionResponse(response, responseWriter, request, action);
+                            final HttpResponse response = httpResponseClassCallbackActionHandler.handle((HttpClassCallback) action, request);
+                            writeResponseActionResponse(response, responseWriter, request, action, synchronous);
                         }
                     }, synchronous);
                     break;
                 }
                 case RESPONSE_OBJECT_CALLBACK: {
-                    final HttpObjectCallback objectCallback = (HttpObjectCallback) action;
                     scheduler.submit(new Runnable() {
                         public void run() {
-                            httpResponseObjectCallbackActionHandler.handle(ActionHandler.this, objectCallback, request, responseWriter);
+                            httpResponseObjectCallbackActionHandler.handle(ActionHandler.this, (HttpObjectCallback) action, request, responseWriter, synchronous);
                         }
                     }, synchronous);
                     break;
                 }
                 case FORWARD: {
-                    final HttpForward httpForward = (HttpForward) action;
                     scheduler.schedule(new Runnable() {
                         public void run() {
-                            final HttpForwardActionResult responseFuture = httpForwardActionHandler.handle(httpForward, request);
+                            final HttpForwardActionResult responseFuture = httpForwardActionHandler.handle((HttpForward) action, request);
                             writeForwardActionResponse(responseFuture, responseWriter, request, action, synchronous);
                         }
-                    }, httpForward.getDelay(), synchronous);
+                    }, synchronous, action.getDelay());
                     break;
                 }
                 case FORWARD_TEMPLATE: {
-                    final HttpTemplate httpTemplate = (HttpTemplate) action;
                     scheduler.schedule(new Runnable() {
                         public void run() {
-                            final HttpForwardActionResult responseFuture = httpForwardTemplateActionHandler.handle(httpTemplate, request);
+                            final HttpForwardActionResult responseFuture = httpForwardTemplateActionHandler.handle((HttpTemplate) action, request);
                             writeForwardActionResponse(responseFuture, responseWriter, request, action, synchronous);
                         }
-                    }, httpTemplate.getDelay(), synchronous);
+                    }, synchronous, action.getDelay());
                     break;
                 }
                 case FORWARD_CLASS_CALLBACK: {
-                    final HttpClassCallback classCallback = (HttpClassCallback) action;
-                    scheduler.submit(new Runnable() {
+                    scheduler.schedule(new Runnable() {
                         public void run() {
-                            final HttpForwardActionResult responseFuture = httpForwardClassCallbackActionHandler.handle(classCallback, request);
+                            final HttpForwardActionResult responseFuture = httpForwardClassCallbackActionHandler.handle((HttpClassCallback) action, request);
                             writeForwardActionResponse(responseFuture, responseWriter, request, action, synchronous);
                         }
-                    }, synchronous);
+                    }, synchronous, action.getDelay());
                     break;
                 }
                 case FORWARD_OBJECT_CALLBACK: {
-                    final HttpObjectCallback objectCallback = (HttpObjectCallback) action;
-                    scheduler.submit(new Runnable() {
+                    scheduler.schedule(new Runnable() {
                         public void run() {
-                            httpForwardObjectCallbackActionHandler.handle(ActionHandler.this, objectCallback, request, responseWriter, synchronous);
+                            httpForwardObjectCallbackActionHandler.handle(ActionHandler.this, (HttpObjectCallback) action, request, responseWriter, synchronous);
                         }
-                    }, synchronous);
+                    }, synchronous, action.getDelay());
                     break;
                 }
                 case FORWARD_REPLACE: {
-                    final HttpOverrideForwardedRequest httpOverrideForwardedRequest = (HttpOverrideForwardedRequest) action;
                     scheduler.schedule(new Runnable() {
                         public void run() {
-                            final HttpForwardActionResult responseFuture = httpOverrideForwardedRequestCallbackActionHandler.handle(httpOverrideForwardedRequest, request);
+                            final HttpForwardActionResult responseFuture = httpOverrideForwardedRequestCallbackActionHandler.handle((HttpOverrideForwardedRequest) action, request);
                             writeForwardActionResponse(responseFuture, responseWriter, request, action, synchronous);
                         }
-                    }, httpOverrideForwardedRequest.getDelay(), synchronous);
+                    }, synchronous, action.getDelay());
                     break;
                 }
                 case ERROR: {
-                    final HttpError httpError = (HttpError) action;
                     scheduler.schedule(new Runnable() {
                         public void run() {
-                            httpErrorActionHandler.handle(httpError, ctx);
-                            mockServerLogger.info(EXPECTATION_RESPONSE, request, "returning error:{}for request:{}for action:{}", httpError, request, action);
+                            httpErrorActionHandler.handle((HttpError) action, ctx);
+                            mockServerLogger.info(EXPECTATION_RESPONSE, request, "returning error:{}for request:{}for action:{}", action, request, action);
                         }
-                    }, httpError.getDelay(), synchronous);
+                    }, synchronous, action.getDelay());
                     break;
                 }
             }
@@ -236,9 +226,13 @@ public void run() {
         }
     }
 
-    void writeResponseActionResponse(HttpResponse response, ResponseWriter responseWriter, HttpRequest request, Action action) {
-        responseWriter.writeResponse(request, response, false);
-        mockServerLogger.info(EXPECTATION_RESPONSE, request, "returning response:{}for request:{}for action:{}", response, request, action);
+    void writeResponseActionResponse(final HttpResponse response, final ResponseWriter responseWriter, final HttpRequest request, final Action action, boolean synchronous) {
+        scheduler.schedule(new Runnable() {
+            public void run() {
+                responseWriter.writeResponse(request, response, false);
+                mockServerLogger.info(EXPECTATION_RESPONSE, request, "returning response:{}for request:{}for action:{}", response, request, action);
+            }
+        }, synchronous, action.getDelay(), response.getDelay());
     }
 
     void writeForwardActionResponse(final HttpForwardActionResult responseFuture, final ResponseWriter responseWriter, final HttpRequest request, final Action action, boolean synchronous) {
@@ -248,7 +242,7 @@ public void run() {
                     HttpResponse response = responseFuture.getHttpResponse().get();
                     responseWriter.writeResponse(request, response, false);
                     httpStateHandler.log(new RequestResponseLogEntry(request, response));
-                    mockServerLogger.info(FORWARDED_REQUEST, request, "returning response:{}for forwarded request\n\n in json:{}\n\n in curl:{}", response, responseFuture.getHttpRequest(), httpRequestToCurlSerializer.toCurl(responseFuture.getHttpRequest()));
+                    mockServerLogger.info(FORWARDED_REQUEST, request, "returning response:{}for forwarded request\n\n in json:{}\n\n in curl:{}for action:{}", response, responseFuture.getHttpRequest(), httpRequestToCurlSerializer.toCurl(responseFuture.getHttpRequest()), action);
                 } catch (Exception ex) {
                     mockServerLogger.error(request, ex, ex.getMessage());
                 }

mockserver-core/src/main/java/org/mockserver/mock/action/HttpResponseObjectCallbackActionHandler.java

@@ -7,6 +7,7 @@
 import org.mockserver.model.HttpRequest;
 import org.mockserver.model.HttpResponse;
 import org.mockserver.responsewriter.ResponseWriter;
+import org.mockserver.scheduler.Scheduler;
 
 import java.util.UUID;
 
@@ -22,13 +23,13 @@ public HttpResponseObjectCallbackActionHandler(HttpStateHandler httpStateHandler
         this.webSocketClientRegistry = httpStateHandler.getWebSocketClientRegistry();
     }
 
-    public void handle(final ActionHandler actionHandler, final HttpObjectCallback httpObjectCallback, final HttpRequest request, final ResponseWriter responseWriter) {
+    public void handle(final ActionHandler actionHandler, final HttpObjectCallback httpObjectCallback, final HttpRequest request, final ResponseWriter responseWriter, final boolean synchronous) {
         String clientId = httpObjectCallback.getClientId();
         String webSocketCorrelationId = UUID.randomUUID().toString();
         webSocketClientRegistry.registerCallbackHandler(webSocketCorrelationId, new WebSocketResponseCallback() {
             @Override
             public void handle(HttpResponse response) {
-                actionHandler.writeResponseActionResponse(response.removeHeader(WEB_SOCKET_CORRELATION_ID_HEADER_NAME), responseWriter, request, httpObjectCallback);
+                actionHandler.writeResponseActionResponse(response.removeHeader(WEB_SOCKET_CORRELATION_ID_HEADER_NAME), responseWriter, request, httpObjectCallback, synchronous);
             }
         });
         webSocketClientRegistry.sendClientMessage(clientId, request.clone().withHeader(WEB_SOCKET_CORRELATION_ID_HEADER_NAME, webSocketCorrelationId));

mockserver-core/src/main/java/org/mockserver/model/Action.java

@@ -2,10 +2,39 @@
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
+import java.util.concurrent.TimeUnit;
+
 /**
  * @author jamesdbloom
  */
-public abstract class Action extends ObjectWithJsonToString {
+public abstract class Action<T extends Action> extends ObjectWithJsonToString {
+
+    private Delay delay;
+
+    /**
+     * The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
+     *
+     * @param delay a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
+     */
+    public T withDelay(Delay delay) {
+        this.delay = delay;
+        return (T) this;
+    }
+
+    /**
+     * The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
+     *
+     * @param timeUnit a the time unit, for example TimeUnit.SECONDS
+     * @param value    a the number of time units to delay the response
+     */
+    public T withDelay(TimeUnit timeUnit, long value) {
+        this.delay = new Delay(timeUnit, value);
+        return (T) this;
+    }
+
+    public Delay getDelay() {
+        return delay;
+    }
 
     @JsonIgnore
     public abstract Type getType();

mockserver-core/src/main/java/org/mockserver/model/HttpClassCallback.java

@@ -5,7 +5,7 @@
 /**
  * @author jamesdbloom
  */
-public class HttpClassCallback extends Action {
+public class HttpClassCallback extends Action<HttpClassCallback> {
 
     private String callbackClass;
     private Type actionType;

mockserver-core/src/main/java/org/mockserver/model/HttpError.java

@@ -7,8 +7,7 @@
 /**
  * @author jamesdbloom
  */
-public class HttpError extends Action {
-    private Delay delay;
+public class HttpError extends Action<HttpError> {
     private Boolean dropConnection;
     private byte[] responseBytes;
 
@@ -44,31 +43,6 @@ public byte[] getResponseBytes() {
         return responseBytes;
     }
 
-    /**
-     * The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     *
-     * @param delay a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     */
-    public HttpError withDelay(Delay delay) {
-        this.delay = delay;
-        return this;
-    }
-
-    /**
-     * The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     *
-     * @param timeUnit a the time unit, for example TimeUnit.SECONDS
-     * @param value    a the number of time units to delay the response
-     */
-    public HttpError withDelay(TimeUnit timeUnit, long value) {
-        this.delay = new Delay(timeUnit, value);
-        return this;
-    }
-
-    public Delay getDelay() {
-        return delay;
-    }
-
     @Override
     @JsonIgnore
     public Type getType() {

mockserver-core/src/main/java/org/mockserver/model/HttpForward.java

@@ -7,12 +7,11 @@
 /**
  * @author jamesdbloom
  */
-public class HttpForward extends Action {
+public class HttpForward extends Action<HttpForward> {
 
     private String host;
     private Integer port = 80;
     private Scheme scheme = Scheme.HTTP;
-    private Delay delay;
 
     /**
      * Static builder to create a callback.
@@ -69,31 +68,6 @@ public HttpForward withScheme(Scheme scheme) {
         return this;
     }
 
-    /**
-     * The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     *
-     * @param delay a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     */
-    public HttpForward withDelay(Delay delay) {
-        this.delay = delay;
-        return this;
-    }
-
-    /**
-     * The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     *
-     * @param timeUnit a the time unit, for example TimeUnit.SECONDS
-     * @param value    a the number of time units to delay the response
-     */
-    public HttpForward withDelay(TimeUnit timeUnit, long value) {
-        this.delay = new Delay(timeUnit, value);
-        return this;
-    }
-
-    public Delay getDelay() {
-        return delay;
-    }
-
     public enum Scheme {
         HTTP,
         HTTPS

mockserver-core/src/main/java/org/mockserver/model/HttpObjectCallback.java

@@ -5,7 +5,7 @@
 /**
  * @author jamesdbloom
  */
-public class HttpObjectCallback extends Action {
+public class HttpObjectCallback extends Action<HttpObjectCallback> {
 
     private String clientId;
     private Type actionType;

mockserver-core/src/main/java/org/mockserver/model/HttpOverrideForwardedRequest.java

@@ -7,10 +7,9 @@
 /**
  * @author jamesdbloom
  */
-public class HttpOverrideForwardedRequest extends Action {
+public class HttpOverrideForwardedRequest extends Action<HttpOverrideForwardedRequest> {
 
     private HttpRequest httpRequest;
-    private Delay delay;
 
     /**
      * Static builder which will allow overriding proxied request with the specified request.
@@ -35,31 +34,6 @@ public HttpOverrideForwardedRequest withHttpRequest(HttpRequest httpRequest) {
         return this;
     }
 
-    /**
-     * The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     *
-     * @param delay a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     */
-    public HttpOverrideForwardedRequest withDelay(Delay delay) {
-        this.delay = delay;
-        return this;
-    }
-
-    /**
-     * The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
-     *
-     * @param timeUnit a the time unit, for example TimeUnit.SECONDS
-     * @param value    a the number of time units to delay the response
-     */
-    public HttpOverrideForwardedRequest withDelay(TimeUnit timeUnit, long value) {
-        this.delay = new Delay(timeUnit, value);
-        return this;
-    }
-
-    public Delay getDelay() {
-        return delay;
-    }
-
     @Override
     @JsonIgnore
     public Type getType() {