Add build args and Dockerfile path override to ImageFromDockerfile (testcontainers#1372)

Author: rnorth

core/src/main/java/org/testcontainers/images/builder/ImageFromDockerfile.java

@@ -23,6 +23,7 @@
 import java.io.PipedOutputStream;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.zip.GZIPOutputStream;
 
@@ -60,6 +61,8 @@ public class ImageFromDockerfile extends LazyFuture<String> implements
     private boolean deleteOnExit = true;
 
     private final Map<String, Transferable> transferables = new HashMap<>();
+    private final Map<String, String> buildArgs = new HashMap<>();
+    private Optional<String> dockerFilePath = Optional.empty();
 
     public ImageFromDockerfile() {
         this("testcontainers/" + Base58.randomString(16).toLowerCase());
@@ -139,5 +142,22 @@ public void onNext(BuildResponseItem item) {
 
     protected void configure(BuildImageCmd buildImageCmd) {
         buildImageCmd.withTag(this.getDockerImageName());
+        this.dockerFilePath.ifPresent(buildImageCmd::withDockerfilePath);
+        this.buildArgs.forEach(buildImageCmd::withBuildArg);
+    }
+
+    public ImageFromDockerfile withBuildArg(final String key, final String value) {
+        this.buildArgs.put(key, value);
+        return this;
+    }
+
+    public ImageFromDockerfile withBuildArgs(final Map<String, String> args) {
+        this.buildArgs.putAll(args);
+        return this;
+    }
+
+    public ImageFromDockerfile withDockerfilePath(String relativePathFromBuildRoot) {
+        this.dockerFilePath = Optional.of(relativePathFromBuildRoot);
+        return this;
     }
 }

core/src/test/java/org/testcontainers/images/builder/DockerfileBuildTest.java

@@ -0,0 +1,67 @@
+package org.testcontainers.images.builder;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.startupcheck.OneShotStartupCheckStrategy;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import static org.rnorth.visibleassertions.VisibleAssertions.assertTrue;
+
+@RunWith(Parameterized.class)
+public class DockerfileBuildTest {
+
+    private static final Path RESOURCE_PATH = Paths.get("src/test/resources/dockerfile-build-test");
+
+    public String expectedFileContent;
+    public ImageFromDockerfile image;
+
+    @Parameterized.Parameters
+    public static Object[][] parameters() {
+        return new Object[][]{
+            // Dockerfile build without explicit per-file inclusion
+            new Object[]{"test1234",
+                // docsShowRecursiveFileInclusion {
+                new ImageFromDockerfile()
+                    .withFileFromPath(".", RESOURCE_PATH)
+                // }
+            },
+
+            // Dockerfile build using a non-standard Dockerfile
+            new Object[]{"test4567",
+                new ImageFromDockerfile()
+                    .withFileFromPath(".", RESOURCE_PATH)
+                    .withDockerfilePath("./Dockerfile-alt")
+            },
+
+            // Dockerfile build using build args
+            new Object[]{"test7890",
+                new ImageFromDockerfile()
+                    .withFileFromPath(".", RESOURCE_PATH)
+                    .withDockerfilePath("./Dockerfile-buildarg")
+                    .withBuildArg("CUSTOM_ARG", "test7890")
+            },
+        };
+    }
+
+    public DockerfileBuildTest(String expectedFileContent, ImageFromDockerfile image) {
+        this.expectedFileContent = expectedFileContent;
+        this.image = image;
+    }
+
+    @Test
+    public void performTest() {
+        try (final GenericContainer container = new GenericContainer(image)
+            .withStartupCheckStrategy(new OneShotStartupCheckStrategy())
+            .withCommand("cat", "/test.txt")) {
+
+            container.start();
+
+            final String logs = container.getLogs();
+            assertTrue("expected file content indicates that dockerfile build steps have been run", logs.contains(expectedFileContent));
+        }
+    }
+}

core/src/test/resources/dockerfile-build-test/Dockerfile

@@ -0,0 +1,2 @@
+FROM alpine:3.2
+COPY localfile.txt /test.txt

core/src/test/resources/dockerfile-build-test/Dockerfile-alt

@@ -0,0 +1,2 @@
+FROM alpine:3.2
+RUN echo "test4567" > /test.txt

core/src/test/resources/dockerfile-build-test/Dockerfile-buildarg

@@ -0,0 +1,3 @@
+FROM alpine:3.2
+ARG CUSTOM_ARG
+RUN echo "${CUSTOM_ARG}" > /test.txt

core/src/test/resources/dockerfile-build-test/localfile.txt

@@ -0,0 +1 @@
+test1234

docs/features/creating_images.md

@@ -9,10 +9,7 @@ image needs to be customized for specific test(s).
 Simply pass a configured instance of `ImageFromDockerfile` as a constructor parameter to `GenericContainer`.
 Testcontainers will `docker build` a temporary container image, and will use it when creating the container.
 
-
-## Examples
-
-### Dockerfile from String, file or classpath resource
+## Dockerfile from String, file or classpath resource
 
 `ImageFromDockerfile` accepts arbitrary files, strings or classpath resources to be used as files in the build context.
 At least one of these needs to be a `Dockerfile`.
@@ -25,14 +22,27 @@ public GenericContainer dslContainer = new GenericContainer(
             .withFileFromClasspath("Dockerfile", "mappable-dockerfile/Dockerfile"))
 ```
 
-The following methods may be used to provide the `Dockerfile` and any other required files:
+The following methods may be used to provide the `Dockerfile` and any other required build context files:
 
 * `withFileFromString(buildContextPath, content)`
 * `withFileFromClasspath(buildContextPath, classpathPath)`
 * `withFileFromPath(buildContextPath, filesystemPath)`
 * `withFileFromFile(buildContextPath, filesystemFile)`
 
-### Dockerfile DSL
+!!! info
+    In older versions of Testcontainers (before 1.3.0) it was necessary to explicitly declare each file that needed to 
+    be present in the Docker build context.
+    This can be replaced with the following syntax:
+    <!--codeinclude--> 
+    [Passing an entire directory of files to the Dockerfile build context](../../core/src/test/java/org/testcontainers/images/builder/DockerfileBuildTest.java) inside_block:docsShowRecursiveFileInclusion
+    <!--/codeinclude-->
+    
+    Where `RESOURCE_PATH` is the path to a directory containing a `Dockerfile` and any files that it needs to refer to.
+    Doing this is equivalent to `docker build RESOURCE_PATH` on the command line.
+    
+    To mimic `docker build .`, `RESOURCE_PATH` would simply be set to `.` as well.
+
+## Dockerfile DSL
 
 If a static Dockerfile is not sufficient (e.g. your test needs to cover many variations that are best generated
 programmatically), there is a DSL available to allow Dockerfiles to be defined in code. e.g.:
@@ -64,3 +74,14 @@ By default the no-args constructor will use an image name of the form `testconta
 * `public ImageFromDockerfile()`
 * `public ImageFromDockerfile(String dockerImageName)`
 * `public ImageFromDockerfile(String dockerImageName, boolean deleteOnExit)`
+
+## Alternative Dockerfiles
+
+Normally Docker will automatically build an image from any `/Dockerfile` that it finds in the root of the build context.
+To override this behaviour, use `.withDockerfilePath("./Name-Of-Other-Dockerfile")`.
+
+## Build Args
+
+[Build Args](https://docs.docker.com/engine/reference/builder/#arg) may be used to allow lightweight parameterization.
+
+To specify build args, use `.withBuildArg("varname", "value")` or provide a `Map` of args using `.withBuildArgs(map)`.