Struct GenericBuildableImage 

pub struct GenericBuildableImage { /* private fields */ }

A generic implementation of BuildableImage for building custom Docker images.

GenericBuildableImage provides a fluent interface for constructing Docker images from Dockerfiles and build contexts. It supports adding files and directories from the filesystem, embedding data directly, and customizing the build process.

Build Context Management

The build context is managed through a BuildContextBuilder that collects all files and data needed for the Docker build. Files are automatically packaged into a TAR archive that gets sent to the Docker daemon.

Example: Basic Image Build

use testcontainers::{GenericBuildableImage, runners::AsyncBuilder};

#[tokio::test]
async fn test_hello() -> anyhow::Result<()> {
    let image = GenericBuildableImage::new("hello-world", "my-tag")
        .with_dockerfile_string(
            r#"FROM alpine:latest
            COPY hello.sh /usr/local/bin/
            RUN chmod +x /usr/local/bin/hello.sh
            CMD ["/usr/local/bin/hello.sh"]"#
        )
        .with_data(
            "#!/bin/sh\necho 'Hello from custom image!'",
            "./hello.sh"
        )
        .build_image().await?;
    // start container
    // use it
}

Example: Multi-File Build Context

use testcontainers::{GenericBuildableImage, runners::AsyncBuilder};

#[tokio::test]
async fn test_webapp() -> anyhow::Result<()>  {
    let image = GenericBuildableImage::new("web-app", "1.0")
        .with_dockerfile("./Dockerfile")
        .with_file("./package.json", "./package.json")
        .with_file("./src", "./src")
        .with_data(vec![0x00, 0x01, 0x02], "./data.dat")
        .build_image().await?;
    // start container
    // use it
}

Implementations

impl GenericBuildableImage

pub fn new(name: impl Into<String>, tag: impl Into<String>) -> Self

Creates a new buildable image with the specified name and tag.

Arguments

• name - The name for the Docker image (e.g., “my-app”, “registry.com/service”)
• tag - The tag for the image (e.g., “latest”, “1.0”, “dev”)

pub fn with_dockerfile(self, source: impl Into<PathBuf>) -> Self

Adds a Dockerfile from the filesystem to the build context.

Arguments

• source - Path to the Dockerfile on the local filesystem

pub fn with_dockerfile_string(self, content: impl Into<String>) -> Self

Adds a Dockerfile from a string to the build context.

This is useful for generating Dockerfiles programmatically or embedding simple Dockerfiles directly in test code.

Arguments

• content - The complete Dockerfile content as a string

pub fn with_file( self, source: impl Into<PathBuf>, target: impl Into<String>, ) -> Self

Adds a file or directory from the filesystem to the build context.

Be aware, that if you don’t add the Dockerfile with the specific with_dockerfile() or with_dockerfile_string() functions it has to be named Dockerfilein the build context. Containerfile won’t be recognized!

Arguments

• source - Path to the file or directory on the local filesystem
• target - Path where the file should be placed in the build context

pub fn with_data( self, data: impl Into<Vec<u8>>, target: impl Into<String>, ) -> Self

Adds data directly to the build context as a file.

This method allows you to embed file content directly without requiring files to exist on the filesystem. Useful for generated content, templates, or small configuration files.

Arguments

• data - The file content as bytes
• target - Path where the file should be placed in the build context

Trait Implementations

impl BuildableImage for GenericBuildableImage

type Built = GenericImage

The type of Image that this buildable image produces after building.

fn build_context(&self) -> CopyToContainerCollection

Returns the build context containing all files and data needed to build the image.

fn descriptor(&self) -> String

Returns the image descriptor (name:tag) that will be assigned to the built image and be passed down to the container for running.

fn into_image(self) -> Self::Built

Consumes this buildable image and converts it into a runnable Image.

impl Debug for GenericBuildableImage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.