Introduce support for WireMock extensions

Author: oleg-nenashev

README.md

@@ -17,7 +17,7 @@ A common example is using Wiremock 3.x with Java 1.8.
 
 ## Usage
 
-Import the dependency:
+### Importing the dependency
 
 ```xml
     <dependency>
@@ -28,8 +28,9 @@ Import the dependency:
     </dependency>
 ```
 
-Use it in your Unit tests.
-Javadoc is coming soon!
+### Using the test container in JUnit 4/5
+
+P.S: Javadoc is coming soon!
 
 ```java
 import org.wiremock.integrations.testcontainers.WireMockContainer;
@@ -68,6 +69,17 @@ public class WireMockContainerTest {
 }
 ```
 
+### Using extensions
+
+The API supports adding [WireMock extensions](https://wiremock.org/docs/extending-wiremock/)
+to the test container.
+The extension can be sourced from the classpath for bundled extensions,
+or added from the JAR file in the initializer.
+
+#### Using external extension
+
+For the , an extension Jar should be 
+
 ## Contributing
 
 All contributions are welcome!

pom.xml

@@ -103,7 +103,50 @@
           </execution>
         </executions>
       </plugin>
+
+      <!-- For testing WireMock extensions -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-dependency-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>copy</id>
+            <phase>package</phase>
+            <goals>
+              <goal>copy</goal>
+              <goal>copy-dependencies</goal>
+            </goals>
+            <configuration>
+              <artifactItems>
+                <artifactItem>
+                  <groupId>com.ninecookies.wiremock.extensions</groupId>
+                  <artifactId>wiremock-extensions</artifactId>
+                  <version>0.4.1</version>
+                  <overWrite>false</overWrite>
+                  <destFileName>9cookies-wiremock-extensions.jar</destFileName>
+                </artifactItem>
+              </artifactItems>
+              <excludeArtifactIds>testcontainers</excludeArtifactIds> <!--Looks like the library defect, it should be provided-->
+              <outputDirectory>${project.build.directory}/test-wiremock-extension</outputDirectory>
+              <overWriteReleases>false</overWriteReleases>
+              <overWriteSnapshots>true</overWriteSnapshots>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
     </plugins>
   </build>
 
+  <!-- For testing WireMock extensions -->
+  <repositories>
+    <repository>
+      <id>9c-releases</id>
+      <url>https://raw.github.com/9cookies/mvn-repo/master/releases/</url>
+      <releases>
+        <enabled>true</enabled>
+        <updatePolicy>always</updatePolicy>
+      </releases>
+    </repository>
+  </repositories>
 </project>

src/main/java/org/wiremock/integrations/testcontainers/WireMockContainer.java

@@ -21,8 +21,16 @@
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.images.builder.Transferable;
@@ -31,6 +39,8 @@
 
 /**
  * Provisions WireMock standalone server as a container.
+ * Designed to follow the WireMock Docker image ({@code wiremock/wiremock}) structure and configuration,
+ * but other images can be included too at your own risk.
  */
 public class WireMockContainer extends GenericContainer<WireMockContainer> {
     private static final String DEFAULT_IMAGE_NAME = "wiremock/wiremock";
@@ -39,12 +49,15 @@ public class WireMockContainer extends GenericContainer<WireMockContainer> {
     private static final String MAPPINGS_DIR = "/home/wiremock/mappings/";
     private static final String FILES_DIR = "/home/wiremock/__files/";
 
+    private static final String EXTENSIONS_DIR = "/var/wiremock/extensions/";
+
     private static final int PORT = 8080;
 
     private final StringBuilder wireMockArgs;
 
     private final Map<String, Stub> mappingStubs = new HashMap<>();
     private final Map<String, MountableFile> mappingFiles = new HashMap<>();
+    private final Map<String, Extension> extensions = new HashMap<>();
 
     public WireMockContainer() {
         this(DEFAULT_TAG);
@@ -115,6 +128,55 @@ public WireMockContainer withFileFromResource(String name, Class<?> resource, St
         return withFileFromResource(name, resource.getName().replace('.', '/') + "/" + filename);
     }
 
+    /**
+     * Add extension that will be loaded from the specified JAR file.
+     * @param id Unique ID of the extension, for logging purposes
+     * @param classNames Class names of the extension to be included
+     * @param jars JARs to be included into the container
+     * @return this instance
+     */
+    public WireMockContainer withExtension(String id, Collection<String> classNames, Collection<File> jars) {
+        final Extension extension = new Extension(id);
+        extension.extensionClassNames.addAll(classNames);
+        extension.jars.addAll(jars);
+        extensions.put(id, extension);
+        return this;
+    }
+
+    /**
+     * Add extension that will be loaded from the specified directory with JAR files.
+     * @param id Unique ID of the extension, for logging purposes
+     * @param classNames Class names of the extension to be included
+     * @param jarDirectory Directory that stores all JARs
+     * @return this instance
+     */
+    public WireMockContainer withExtension(String id, Collection<String> classNames, File jarDirectory) {
+        final List<File> jarsInTheDirectory;
+        try (Stream<Path> walk = Files.walk(jarDirectory.toPath())) {
+            jarsInTheDirectory = walk
+                    .filter(p -> !Files.isDirectory(p))
+                    .map(Path::toFile)
+                    .filter(f -> f.toString().endsWith(".jar"))
+                    .collect(Collectors.toList());
+        } catch (IOException e) {
+            throw new IllegalArgumentException("Cannot list JARs in the directory " + jarDirectory, e);
+        }
+
+        return withExtension(id, classNames, jarsInTheDirectory);
+    }
+
+    /**
+     * Add extension that will be loaded from the classpath.
+     * This method can be used if the extension is a part of the WireMock bundle,
+     * or a Jar is already added via {@link #withExtension(String, Collection, Collection)}}
+     * @param id Unique ID of the extension, for logging purposes
+     * @param className Class name of the extension
+     * @return this instance
+     */
+    public WireMockContainer withExtension(String id, String className) {
+        return withExtension(id, Collections.singleton(className), Collections.emptyList());
+    }
+
     public String getEndpoint() {
         return String.format("http://%s:%d", getHost(), getMappedPort(PORT));
     }
@@ -131,14 +193,33 @@ public Integer getServerPort() {
     protected void configure() {
         super.configure();
         withExposedPorts(PORT);
-        withCommand(wireMockArgs.toString());
         for (Stub stub : mappingStubs.values()) {
             withCopyToContainer(Transferable.of(stub.json), MAPPINGS_DIR + stub.name + ".json");
         }
 
         for (Map.Entry<String, MountableFile> mount : mappingFiles.entrySet()) {
             withCopyToContainer(mount.getValue(), FILES_DIR + mount.getKey());
         }
+
+        final ArrayList<String> extensionClassNames = new ArrayList<>();
+        for (Map.Entry<String, Extension> entry : extensions.entrySet()) {
+            final Extension ext = entry.getValue();
+            extensionClassNames.addAll(ext.extensionClassNames);
+            for (File jar : ext.jars) {
+                withCopyToContainer(MountableFile.forHostPath(jar.toPath()), EXTENSIONS_DIR + jar.getName());
+            }
+        }
+        if (!extensionClassNames.isEmpty()) {
+            wireMockArgs.append(" --extensions ");
+            int counter = 0;
+            for (String className : extensionClassNames) {
+                wireMockArgs.append(className);
+                wireMockArgs.append( (++counter != extensionClassNames.size()) ? ',' : ' ');
+            }
+        }
+
+        // Add CLI arguments
+        withCommand(wireMockArgs.toString());
     }
 
     private static final class Stub {
@@ -151,4 +232,14 @@ public Stub (String name, String json) {
         }
     }
 
+    private static final class Extension {
+        final String id;
+        final List<File> jars = new ArrayList<>();
+        final List<String> extensionClassNames = new ArrayList<>();
+
+        public Extension(String id) {
+            this.id = id;
+        }
+    }
+
 }

src/test/java/org/wiremock/integrations/testcontainers/WireMockContainerExtensionTest.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2023 WireMock Inc, Oleg Nenashev and all project contributors
+ *
+ * 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.wiremock.integrations.testcontainers;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.file.Paths;
+import java.time.Duration;
+import java.util.Collections;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests the WireMock extension loading.
+ * It uses the external Jar supplied by the Maven Dependency Plugin.
+ */
+public class WireMockContainerExtensionTest {
+
+    public static final Logger LOGGER =  LoggerFactory.getLogger(WireMockContainerExtensionTest.class);
+
+    @Rule
+    public WireMockContainer wiremockServer = new WireMockContainer("2.35.0")
+            .withStartupTimeout(Duration.ofSeconds(60))
+            .withMapping("json-body-transformer", WireMockContainerExtensionTest.class, "json-body-transformer.json")
+            .withExtension("JSON Body Transformer", Collections.singleton("com.ninecookies.wiremock.extensions.JsonBodyTransformer"),
+                    Collections.singleton(Paths.get("target", "test-wiremock-extension", "9cookies-wiremock-extensions.jar").toFile()));
+
+    @Before
+    public void before() {
+        wiremockServer.followOutput(new Slf4jLogConsumer(LOGGER));
+    }
+
+    @Test
+    public void testJSONBodyTransformer() throws Exception {
+        final HttpClient client = HttpClient.newBuilder().build();
+        final HttpRequest request = HttpRequest.newBuilder()
+                .uri(wiremockServer.getRequestURI("json-body-transformer"))
+                .timeout(Duration.ofSeconds(10))
+                .header("Content-Type", "application/json")
+                .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"John Doe\"}")).build();
+
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.body())
+                .as("Wrong response body")
+                .contains("Hello, John Doe!");
+    }
+
+}

src/test/java/org/wiremock/integrations/testcontainers/WireMockContainerTest.java

@@ -35,19 +35,14 @@ public class WireMockContainerTest {
 
     @Test
     public void helloWorld() throws Exception {
-        final HttpClient client = HttpClient.newBuilder()
-                .version(HttpClient.Version.HTTP_1_1)
-                .build();
-
-        HttpRequest request = HttpRequest.newBuilder()
+        final HttpClient client = HttpClient.newBuilder().build();
+        final HttpRequest request = HttpRequest.newBuilder()
                 .uri(wiremockServer.getRequestURI("hello"))
                 .timeout(Duration.ofSeconds(10))
                 .header("Content-Type", "application/json")
-                .GET()
-                .build();
+                .GET().build();
 
-        HttpResponse<String> response =
-                client.send(request, HttpResponse.BodyHandlers.ofString());
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 
         assertThat(response.body())
                 .as("Wrong response body")

src/test/resources/org/wiremock/integrations/testcontainers/WireMockContainerExtensionTest/json-body-transformer.json

@@ -0,0 +1,16 @@
+{
+  "request": {
+    "method": "POST",
+    "url": "/json-body-transformer"
+  },
+  "response": {
+    "status": 201,
+    "headers": {
+      "content-type": "application/json"
+    },
+    "jsonBody": {
+      "message": "Hello, $(name)!"
+    },
+    "transformers" : ["json-body-transformer"]
+  }
+}