Allow health check timeout configuration

Author: martin-tarjanyi

src/main/java/io/specto/hoverfly/junit/core/Hoverfly.java

@@ -12,16 +12,6 @@
  */
 package io.specto.hoverfly.junit.core;
 
-import static io.specto.hoverfly.junit.core.HoverflyConfig.localConfigs;
-import static io.specto.hoverfly.junit.core.HoverflyMode.CAPTURE;
-import static io.specto.hoverfly.junit.core.HoverflyMode.DIFF;
-import static io.specto.hoverfly.junit.core.HoverflyUtils.checkPortInUse;
-import static io.specto.hoverfly.junit.core.HoverflyUtils.readSimulationFromString;
-import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.any;
-import static io.specto.hoverfly.junit.verification.HoverflyVerifications.atLeastOnce;
-import static io.specto.hoverfly.junit.verification.HoverflyVerifications.never;
-import static io.specto.hoverfly.junit.verification.HoverflyVerifications.times;
-
 import io.specto.hoverfly.junit.api.HoverflyClient;
 import io.specto.hoverfly.junit.api.HoverflyClientException;
 import io.specto.hoverfly.junit.api.model.ModeArguments;
@@ -38,6 +28,12 @@
 import io.specto.hoverfly.junit.verification.HoverflyDiffAssertionError;
 import io.specto.hoverfly.junit.verification.VerificationCriteria;
 import io.specto.hoverfly.junit.verification.VerificationData;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.zeroturnaround.exec.ProcessExecutor;
+import org.zeroturnaround.exec.StartedProcess;
+
 import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -58,20 +54,23 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.zeroturnaround.exec.ProcessExecutor;
-import org.zeroturnaround.exec.StartedProcess;
+
+import static io.specto.hoverfly.junit.core.HoverflyConfig.localConfigs;
+import static io.specto.hoverfly.junit.core.HoverflyMode.CAPTURE;
+import static io.specto.hoverfly.junit.core.HoverflyMode.DIFF;
+import static io.specto.hoverfly.junit.core.HoverflyUtils.checkPortInUse;
+import static io.specto.hoverfly.junit.core.HoverflyUtils.readSimulationFromString;
+import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.any;
+import static io.specto.hoverfly.junit.verification.HoverflyVerifications.atLeastOnce;
+import static io.specto.hoverfly.junit.verification.HoverflyVerifications.never;
+import static io.specto.hoverfly.junit.verification.HoverflyVerifications.times;
 
 /**
  * A wrapper class for the Hoverfly binary.  Manage the lifecycle of the processes, and then manage Hoverfly itself by using it's API endpoints.
  */
 public class Hoverfly implements AutoCloseable {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(Hoverfly.class);
-    private static final int BOOT_TIMEOUT_SECONDS = 10;
-    private static final int RETRY_BACKOFF_INTERVAL_MS = 100;
 
 
     private final HoverflyConfiguration hoverflyConfig;
@@ -533,16 +532,17 @@ private void persistSimulation(Path path, Simulation simulation) throws IOExcept
     private void waitForHoverflyToBecomeHealthy() {
         final Instant now = Instant.now();
 
-        while (Duration.between(now, Instant.now()).getSeconds() < BOOT_TIMEOUT_SECONDS) {
+        while (Duration.between(now, Instant.now()).toMillis() < hoverflyConfig.getHealthCheckTimeout().toMillis()) {
             if (hoverflyClient.getHealth()) return;
             try {
                 // TODO: prefer executors and tasks to threads
-                Thread.sleep(RETRY_BACKOFF_INTERVAL_MS);
+                Thread.sleep(hoverflyConfig.getHealthCheckRetryInterval().toMillis());
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
         }
-        throw new IllegalStateException("Hoverfly has not become healthy in " + BOOT_TIMEOUT_SECONDS + " seconds");
+        throw new IllegalStateException(
+            "Hoverfly has not become healthy in " + hoverflyConfig.getHealthCheckTimeout().toMillis() + " milliseconds");
     }
 
     private void setModeWithArguments(HoverflyMode mode, HoverflyConfiguration config) {

src/main/java/io/specto/hoverfly/junit/core/HoverflyConstants.java

@@ -1,11 +1,17 @@
 package io.specto.hoverfly.junit.core;
 
+import java.time.Duration;
+
 public class HoverflyConstants {
 
     public static final int DEFAULT_PROXY_PORT = 8500;
     public static final int DEFAULT_ADMIN_PORT = 8888;
     public static final int DEFAULT_HTTPS_ADMIN_PORT = 443;
 
+    // Timeout
+    public static final Duration DEFAULT_HEALTH_CHECK_TIMEOUT = Duration.ofSeconds(10);
+    public static final Duration DEFAULT_HEALTH_CHECK_RETRY_INTERVAL = Duration.ofMillis(100);
+
     // Hoverfly custom auth header name
     public static final String X_HOVERFLY_AUTHORIZATION = "X-HOVERFLY-AUTHORIZATION";
 

src/main/java/io/specto/hoverfly/junit/core/config/HoverflyConfigValidator.java

@@ -3,14 +3,13 @@
 import io.specto.hoverfly.junit.core.Hoverfly;
 import io.specto.hoverfly.junit.core.HoverflyConfig;
 import io.specto.hoverfly.junit.core.HoverflyConstants;
-import java.net.URL;
-import java.nio.file.Paths;
 import org.apache.commons.lang3.StringUtils;
 
 import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.net.URL;
 import java.util.Optional;
 
 
@@ -69,6 +68,14 @@ HoverflyConfiguration validate(HoverflyConfiguration hoverflyConfig) {
             }
         }
 
+        if (hoverflyConfig.getHealthCheckTimeout() == null) {
+            hoverflyConfig.setHealthCheckTimeout(HoverflyConstants.DEFAULT_HEALTH_CHECK_TIMEOUT);
+        }
+
+        if (hoverflyConfig.getHealthCheckRetryInterval() == null) {
+            hoverflyConfig.setHealthCheckRetryInterval(HoverflyConstants.DEFAULT_HEALTH_CHECK_RETRY_INTERVAL);
+        }
+
         // Check proxy CA cert exists
         if (hoverflyConfig.getProxyCaCertificate().isPresent()) {
             checkResourceOnClasspath(hoverflyConfig.getProxyCaCertificate().get());

src/main/java/io/specto/hoverfly/junit/core/config/HoverflyConfiguration.java

@@ -4,6 +4,7 @@
 import io.specto.hoverfly.junit.core.SimulationPreprocessor;
 import org.slf4j.Logger;
 
+import java.time.Duration;
 import java.util.List;
 import java.util.Optional;
 
@@ -47,6 +48,8 @@ public class HoverflyConfiguration {
     private String clientCaCertPath;
     private String responseBodyFilesPath;
     private boolean isRelativeResponseBodyFilesPath;
+    private Duration healthCheckTimeout;
+    private Duration healthCheckRetryInterval;
 
     /**
      * Create configurations for external hoverfly
@@ -353,4 +356,20 @@ public boolean isRelativeResponseBodyFilesPath() {
     public void setRelativeResponseBodyFilesPath(boolean relativeResponseBodyFilesPath) {
         isRelativeResponseBodyFilesPath = relativeResponseBodyFilesPath;
     }
+
+    public Duration getHealthCheckTimeout() {
+        return healthCheckTimeout;
+    }
+
+    public void setHealthCheckTimeout(Duration healthCheckTimeout) {
+        this.healthCheckTimeout = healthCheckTimeout;
+    }
+
+    public Duration getHealthCheckRetryInterval() {
+        return healthCheckRetryInterval;
+    }
+
+    public void setHealthCheckRetryInterval(Duration healthCheckRetryInterval) {
+        this.healthCheckRetryInterval = healthCheckRetryInterval;
+    }
 }

src/main/java/io/specto/hoverfly/junit/core/config/LocalHoverflyConfig.java

@@ -14,12 +14,14 @@
 
 import io.specto.hoverfly.junit.core.Hoverfly;
 import io.specto.hoverfly.junit.core.HoverflyConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.net.InetSocketAddress;
+import java.time.Duration;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * Config builder interface for settings specific to {@link Hoverfly} managed internally
@@ -40,6 +42,8 @@ public class LocalHoverflyConfig extends HoverflyConfig {
     private String clientKeyPath;
     private String clientAuthDestination;
     private String clientCaCertPath;
+    private Duration healthCheckTimeout;
+    private Duration healthCheckRetryInterval;
 
     /**
      * Sets the certificate file to override the default Hoverfly's CA cert
@@ -202,6 +206,26 @@ public LocalHoverflyConfig clientAuthCaCertPath(String clientCaCertPath) {
         return this;
     }
 
+    /**
+     * Set the maximum time to wait for Hoverfly to be healthy.
+     * @param healthCheckTimeout the health check timeout
+     * @return the {@link HoverflyConfig} for further customizations
+     */
+    public HoverflyConfig healthCheckTimeout(Duration healthCheckTimeout) {
+        this.healthCheckTimeout = healthCheckTimeout;
+        return this;
+    }
+
+    /**
+     * Set the interval between health checks.
+     * @param healthCheckRetryInterval the health check retry interval
+     * @return the {@link HoverflyConfig} for further customizations
+     */
+    public HoverflyConfig healthCheckRetryInterval(Duration healthCheckRetryInterval) {
+        this.healthCheckRetryInterval = healthCheckRetryInterval;
+        return this;
+    }
+
     @Override
     public HoverflyConfiguration build() {
         HoverflyConfiguration configs = new HoverflyConfiguration(proxyPort, adminPort, proxyLocalHost, destination,
@@ -220,6 +244,8 @@ public HoverflyConfiguration build() {
         configs.setClientCaCertPath(clientCaCertPath);
         configs.setResponseBodyFilesPath(responseBodyFilesPath);
         configs.setRelativeResponseBodyFilesPath(isRelativeResponseBodyFilesPath);
+        configs.setHealthCheckTimeout(healthCheckTimeout);
+        configs.setHealthCheckRetryInterval(healthCheckRetryInterval);
         HoverflyConfigValidator validator = new HoverflyConfigValidator();
         return validator.validate(configs);
     }

src/main/java/io/specto/hoverfly/junit/core/config/RemoteHoverflyConfig.java

@@ -4,6 +4,8 @@
 import io.specto.hoverfly.junit.core.HoverflyConfig;
 import io.specto.hoverfly.junit.core.HoverflyConstants;
 
+import java.time.Duration;
+
 import static io.specto.hoverfly.junit.core.HoverflyConstants.DEFAULT_ADMIN_PORT;
 import static io.specto.hoverfly.junit.core.HoverflyConstants.DEFAULT_PROXY_PORT;
 
@@ -16,6 +18,8 @@ public class RemoteHoverflyConfig extends HoverflyConfig {
     private String scheme;
     private String authToken;
     private String adminCertificate; // file name relative to test resources folder
+    private Duration healthCheckTimeout;
+    private Duration healthCheckRetryInterval;
 
 
     /**
@@ -59,6 +63,26 @@ public RemoteHoverflyConfig withHttpsAdminEndpoint() {
         return this;
     }
 
+    /**
+     * Set the maximum time to wait for Hoverfly to be healthy.
+     * @param healthCheckTimeout the health check timeout
+     * @return the {@link HoverflyConfig} for further customizations
+     */
+    public HoverflyConfig healthCheckTimeout(Duration healthCheckTimeout) {
+        this.healthCheckTimeout = healthCheckTimeout;
+        return this;
+    }
+
+    /**
+     * Set the interval between health checks.
+     * @param healthCheckRetryInterval the health check retry interval
+     * @return the {@link HoverflyConfig} for further customizations
+     */
+    public HoverflyConfig healthCheckRetryInterval(Duration healthCheckRetryInterval) {
+        this.healthCheckRetryInterval = healthCheckRetryInterval;
+        return this;
+    }
+
     // TODO add support for custom server certificate for admin endpoint
 
     @Override
@@ -72,6 +96,8 @@ public HoverflyConfiguration build() {
         HoverflyConfiguration configs = new HoverflyConfiguration(scheme, host, proxyPort, adminPort, proxyLocalHost,
                 destination, proxyCaCert, authToken, adminCertificate, captureHeaders, webServer, statefulCapture, incrementalCapture,
                 simulationPreprocessor);
+        configs.setHealthCheckTimeout(healthCheckTimeout);
+        configs.setHealthCheckRetryInterval(healthCheckRetryInterval);
         HoverflyConfigValidator validator = new HoverflyConfigValidator();
         return validator.validate(configs);
     }

src/test/java/io/specto/hoverfly/junit/core/HoverflyConfigTest.java

@@ -1,19 +1,19 @@
 package io.specto.hoverfly.junit.core;
 
 import io.specto.hoverfly.junit.core.config.HoverflyConfiguration;
-import java.net.InetSocketAddress;
-import java.util.Optional;
-
 import io.specto.hoverfly.junit.core.config.LogLevel;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.contrib.java.lang.system.EnvironmentVariables;
 import org.slf4j.LoggerFactory;
 
+import java.net.InetSocketAddress;
+import java.time.Duration;
+import java.util.Optional;
+
 import static io.specto.hoverfly.junit.core.HoverflyConfig.localConfigs;
 import static io.specto.hoverfly.junit.core.HoverflyConfig.remoteConfigs;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 
 public class HoverflyConfigTest {
@@ -47,6 +47,9 @@ public void shouldHaveDefaultSettings() {
         assertThat(configs.getClientKeyPath()).isNull();
         assertThat(configs.getClientAuthDestination()).isNull();
         assertThat(configs.getClientCaCertPath()).isNull();
+
+        assertThat(configs.getHealthCheckTimeout()).isEqualTo(Duration.ofSeconds(10));
+        assertThat(configs.getHealthCheckRetryInterval()).isEqualTo(Duration.ofMillis(100));
     }
 
     @Test
@@ -237,4 +240,31 @@ public void shouldSetClientAuthCaCert() {
         assertThat(configs.getClientCaCertPath()).isEqualTo("ssl/ca.pem");
     }
 
+    @Test
+    public void shouldSetHealthCheckTimeoutInLocalConfig() {
+        HoverflyConfiguration configs = localConfigs().healthCheckTimeout(Duration.ofSeconds(20)).build();
+
+        assertThat(configs.getHealthCheckTimeout()).isEqualTo(Duration.ofSeconds(20));
+    }
+
+    @Test
+    public void shouldSetHealthCheckRetryIntervalInLocalConfig() {
+        HoverflyConfiguration configs = localConfigs().healthCheckRetryInterval(Duration.ofSeconds(5)).build();
+
+        assertThat(configs.getHealthCheckRetryInterval()).isEqualTo(Duration.ofSeconds(5));
+    }
+
+    @Test
+    public void shouldSetHealthCheckTimeoutInRemoteConfig() {
+        HoverflyConfiguration configs = remoteConfigs().healthCheckTimeout(Duration.ofSeconds(20)).build();
+
+        assertThat(configs.getHealthCheckTimeout()).isEqualTo(Duration.ofSeconds(20));
+    }
+
+    @Test
+    public void shouldSetHealthCheckRetryIntervalInRemoteConfig() {
+        HoverflyConfiguration configs = remoteConfigs().healthCheckRetryInterval(Duration.ofSeconds(5)).build();
+
+        assertThat(configs.getHealthCheckRetryInterval()).isEqualTo(Duration.ofSeconds(5));
+    }
 }