Merge pull request #146 from aguibert/hollow-path

Introduce microshed_app_context_root for Manual/Hollow environments

Author: aguibert

core/src/main/java/org/microshed/testing/ManuallyStartedConfiguration.java

@@ -18,6 +18,9 @@
  */
 package org.microshed.testing;
 
+import java.net.MalformedURLException;
+import java.net.URL;
+
 /**
  * Configuration representing application and dependent services already
  * being started prior to running the tests.
@@ -27,10 +30,10 @@ public class ManuallyStartedConfiguration implements ApplicationEnvironment {
     public static final String MICROSHED_HOSTNAME = "microshed_hostname";
     public static final String MICROSHED_HTTP_PORT = "microshed_http_port";
     public static final String MICROSHED_HTTPS_PORT = "microshed_https_port";
-//    public static final String RUNTIME_URL_PROPERTY = "MICROSHED_TEST_RUNTIME_URL";
+    public static final String MICROSHED_APP_CONTEXT_ROOT = "microshed_app_context_root";
     public static final String MANUAL_ENALBED = "microshed_manual_env";
 
-    private static String runtimeURL;
+    private static URL runtimeURL;
 
     @Override
     public boolean isAvailable() {
@@ -48,28 +51,58 @@ public int getPriority() {
     }
 
     public static void setRuntimeURL(String url) {
-        runtimeURL = url;
+        try {
+            runtimeURL = new URL(url);
+        } catch (MalformedURLException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    public static String getHostname() {
+        if (runtimeURL != null)
+            return runtimeURL.getHost();
+        return resolveProperty(MICROSHED_HOSTNAME);
+    }
+
+    public static int getHttpPort() {
+        if (runtimeURL != null && runtimeURL.toString().startsWith("http://"))
+            return runtimeURL.getPort() == -1 ? runtimeURL.getDefaultPort() : runtimeURL.getPort();
+        String port = resolveProperty(MICROSHED_HTTP_PORT);
+        return port.isEmpty() ? -1 : Integer.valueOf(port);
+    }
+
+    public static int getHttpsPort() {
+        if (runtimeURL != null && runtimeURL.toString().startsWith("https://"))
+            return runtimeURL.getPort() == -1 ? runtimeURL.getDefaultPort() : runtimeURL.getPort();
+        String port = resolveProperty(MICROSHED_HTTPS_PORT);
+        return port.isEmpty() ? -1 : Integer.valueOf(port);
+    }
+
+    public static String getBasePath() {
+        String basePath = runtimeURL != null ? runtimeURL.getPath() : resolveProperty(MICROSHED_APP_CONTEXT_ROOT);
+        if (!basePath.startsWith("/"))
+            basePath = "/" + basePath;
+        return basePath;
     }
 
     public static String getRuntimeURL() {
         if (runtimeURL != null)
-            return runtimeURL;
+            return runtimeURL.toString();
 
-        String host = resolveProperty(MICROSHED_HOSTNAME);
-        String httpPort = resolveProperty(MICROSHED_HTTP_PORT);
-        String httpsPort = resolveProperty(MICROSHED_HTTPS_PORT);
-        if (host.isEmpty() && (httpPort.isEmpty() || httpsPort.isEmpty())) {
+        String host = getHostname();
+        int httpPort = getHttpPort();
+        int httpsPort = getHttpsPort();
+        if (host.isEmpty() || (httpPort == -1 && httpsPort == -1)) {
             throw new IllegalStateException("The properties '" + MICROSHED_HOSTNAME + "' and '" + MICROSHED_HTTP_PORT + "' or '" +
                                             MICROSHED_HTTPS_PORT + "' must be set in order to use this ApplicationEnvironment");
         }
+        String basePath = getBasePath();
 
         // Prefer HTTPS if set
-        if (!httpsPort.isEmpty()) {
-            Integer.parseInt(httpsPort);
-            return "https://" + host + ':' + httpsPort;
+        if (httpsPort != -1) {
+            return "https://" + host + ':' + httpsPort + basePath;
         } else {
-            Integer.parseInt(httpPort);
-            return "http://" + host + ':' + httpPort;
+            return "http://" + host + ':' + httpPort + basePath;
         }
     }
 

modules/testcontainers/src/main/java/org/microshed/testing/testcontainers/ApplicationContainer.java

@@ -23,7 +23,6 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -45,6 +44,7 @@
 import org.junit.jupiter.api.extension.ExtensionConfigurationException;
 import org.junit.platform.commons.support.AnnotationSupport;
 import org.microshed.testing.ApplicationEnvironment;
+import org.microshed.testing.ManuallyStartedConfiguration;
 import org.microshed.testing.testcontainers.config.HollowTestcontainersConfiguration;
 import org.microshed.testing.testcontainers.config.TestcontainersConfiguration;
 import org.microshed.testing.testcontainers.internal.ImageFromDockerfile;
@@ -118,9 +118,8 @@ private static Future<String> resolveImage(Optional<Path> dockerfile) {
     }
 
     private static boolean isHollow() {
-        ApplicationEnvironment current = ApplicationEnvironment.Resolver.load();
-        return !(current instanceof TestcontainersConfiguration) ||
-               current instanceof HollowTestcontainersConfiguration;
+        return ApplicationEnvironment.Resolver.isSelected(HollowTestcontainersConfiguration.class) ||
+               ApplicationEnvironment.Resolver.isSelected(ManuallyStartedConfiguration.class);
     }
 
     private static File findAppFile() {
@@ -222,6 +221,14 @@ private void commonInit() {
         addExposedPorts(serverAdapter.getDefaultHttpPort());
         withLogConsumer(new Slf4jLogConsumer(LOGGER));
         withAppContextRoot("/");
+        if (isHollow) {
+            setContainerIpAddress(ManuallyStartedConfiguration.getHostname());
+            if (ManuallyStartedConfiguration.getHttpsPort() != -1)
+                setFirstMappedPort(ManuallyStartedConfiguration.getHttpsPort());
+            else
+                setFirstMappedPort(ManuallyStartedConfiguration.getHttpPort());
+            withAppContextRoot(ManuallyStartedConfiguration.getBasePath());
+        }
     }
 
     @Override
@@ -239,17 +246,16 @@ protected void configure() {
         }
     }
 
-    /**
-     * Sets the URL where the current application is running at. This method is typically called
-     * for plugins that make use of {@link HollowTestcontainersConfiguration}. It is not necessary
-     * for test code to call this method if they are starting the application container in the
-     * normal way.
-     *
-     * @param url The URl where the current application is running
-     */
-    public void setRunningURL(URL url) {
-        lateBind_ipAddress = url.getHost();
-        lateBind_port = url.getPort() == -1 ? url.getDefaultPort() : url.getPort();
+    public void setContainerIpAddress(String ipAddress) {
+        if (!isHollow)
+            throw new IllegalStateException("Can only set contaienr IP address in hollow mode");
+        lateBind_ipAddress = ipAddress;
+    }
+
+    public void setFirstMappedPort(int port) {
+        if (!isHollow)
+            throw new IllegalStateException("Can only set first mapped port in hollow mode");
+        lateBind_port = port;
     }
 
     @Override
@@ -453,9 +459,9 @@ public String getApplicationURL() {
      *         {@code http://<container-ip-address>:<mapped-port>}
      */
     public String getBaseURL() {
-        if (!this.isRunning())
+        if (!isHollow && !isRunning())
             throw new IllegalStateException("Container must be running to determine hostname and port");
-        return "http://" + this.getContainerIpAddress() + ':' + this.getFirstMappedPort();
+        return "http://" + getContainerIpAddress() + ':' + getFirstMappedPort();
     }
 
     /**

modules/testcontainers/src/main/java/org/microshed/testing/testcontainers/config/HollowTestcontainersConfiguration.java

@@ -94,24 +94,6 @@ public void applyConfiguration(Class<?> testClass) {
         } catch (Exception e) {
             e.printStackTrace();
         }
-
-        // Apply configuration to a running server
-        URL appURL;
-        String runtimeURL = getApplicationURL();
-        try {
-            appURL = new URL(runtimeURL);
-        } catch (MalformedURLException e) {
-            throw new ExtensionConfigurationException("The application URL '" + runtimeURL + "' was not a valid URL.", e);
-        }
-        allContainers().stream()
-                        .filter(c -> c instanceof ApplicationContainer)
-                        .map(c -> (ApplicationContainer) c)
-                        .forEach(c -> c.setRunningURL(appURL));
-    }
-
-    @Override
-    public String getApplicationURL() {
-        return ManuallyStartedConfiguration.getRuntimeURL();
     }
 
     /**

modules/testcontainers/src/main/java/org/microshed/testing/testcontainers/config/TestcontainersConfiguration.java

@@ -46,10 +46,10 @@ public class TestcontainersConfiguration implements ApplicationEnvironment {
     private static final Logger LOG = LoggerFactory.getLogger(TestcontainersConfiguration.class);
 
     // Will need to rework this if we will ever support parallel test execution
-    private static Class<?> currentTestClass;
-    private static Class<? extends SharedContainerConfiguration> sharedConfigClass;
-    private static final Set<GenericContainer<?>> unsharedContainers = new HashSet<>();
-    private static final Set<GenericContainer<?>> sharedContainers = new HashSet<>();
+    private Class<?> currentTestClass;
+    private Class<? extends SharedContainerConfiguration> sharedConfigClass;
+    private final Set<GenericContainer<?>> unsharedContainers = new HashSet<>();
+    private final Set<GenericContainer<?>> sharedContainers = new HashSet<>();
 
     @Override
     public int getPriority() {
@@ -63,7 +63,7 @@ public boolean isAvailable() {
 
     @Override
     public void applyConfiguration(Class<?> testClass) {
-        TestcontainersConfiguration.currentTestClass = testClass;
+        currentTestClass = testClass;
 
         if (testClass.isAnnotationPresent(SharedContainerConfig.class)) {
             sharedConfigClass = testClass.getAnnotation(SharedContainerConfig.class).value();
@@ -139,12 +139,6 @@ public void start() {
     @Override
     public String getApplicationURL() {
         ApplicationContainer mpApp = autoDiscoverMPApp(currentTestClass, true);
-
-        // At this point we have found exactly one ApplicationContainer
-        if (!mpApp.isCreated() || !mpApp.isRunning())
-            throw new ExtensionConfigurationException("ApplicationContainer " + mpApp.getDockerImageName() + " is not running yet. " +
-                                                      "The contianer must be running in order to obtain its URL.");
-
         return mpApp.getApplicationURL();
     }
 
@@ -159,7 +153,7 @@ private boolean isJwtNeeded() {
         return AnnotationSupport.findAnnotatedFields(currentTestClass, JwtConfig.class).size() > 0;
     }
 
-    private ApplicationContainer autoDiscoverMPApp(Class<?> clazz, boolean errorIfNone) {
+    ApplicationContainer autoDiscoverMPApp(Class<?> clazz, boolean errorIfNone) {
         // First check for any MicroProfileApplicaiton directly present on the test class
         List<Field> mpApps = AnnotationSupport.findAnnotatedFields(clazz, Container.class,
                                                                    f -> Modifier.isStatic(f.getModifiers()) &&

modules/testcontainers/src/test/java/org/microshed/testing/testcontainers/config/HollowTestcontainersConfigurationTest.java

@@ -88,7 +88,7 @@ public void testEnvVarUnchanged() {
 
     @Test
     public void testApplicationURL() {
-        assertEquals("http://localhost:9080", ApplicationEnvironment.Resolver.load().getApplicationURL());
+        assertEquals("http://localhost:9080/", ApplicationEnvironment.Resolver.load().getApplicationURL());
     }
 
 }

modules/testcontainers/src/test/java/org/microshed/testing/testcontainers/config/HollowTestcontainersConfigurationTest2.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2019 IBM Corporation and others
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.microshed.testing.testcontainers.config;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.nio.file.Paths;
+
+import org.junit.jupiter.api.Test;
+import org.microshed.testing.ApplicationEnvironment;
+import org.microshed.testing.jupiter.MicroShedTest;
+import org.microshed.testing.testcontainers.ApplicationContainer;
+import org.testcontainers.junit.jupiter.Container;
+
+@MicroShedTest
+public class HollowTestcontainersConfigurationTest2 {
+
+    // This cointainer never actually gets started, since we are running in hollow mode
+    @Container
+    public static ApplicationContainer app = new ApplicationContainer(Paths.get("src", "test", "resources", "Dockerfile"))
+                    .withExposedPorts(9443)
+                    .withAppContextRoot("/myservice");
+
+    @Test
+    public void testCorrectEnvironment() {
+        assertEquals(HollowTestcontainersConfiguration.class, ApplicationEnvironment.Resolver.load().getClass());
+        assertTrue(ApplicationEnvironment.Resolver.isSelected(HollowTestcontainersConfiguration.class),
+                   "Expected HollowTestcontainersConfiguration to be selected but it was not");
+        assertTrue(HollowTestcontainersConfiguration.available(),
+                   "Expected HollowTestcontainersConfiguration to be available but it was not");
+    }
+
+    @Test
+    public void testApplicationURLWithPath() {
+        assertEquals("http://localhost:9080/myservice", ApplicationEnvironment.Resolver.load().getApplicationURL());
+    }
+
+}