Struct GenericImage

pub struct GenericImage { /* private fields */ }

A configurable image from which a Container or ContainerAsync can be started.

The various methods on this struct allow for configuring the resulting container using the builder pattern. Further configuration is available through the ImageExt extension trait. Make sure to invoke the configuration methods on GenericImage first, before those from ImageExt.

For example:

use testcontainers::{
    core::{IntoContainerPort, WaitFor}, runners::AsyncRunner, GenericImage, ImageExt
};

#[tokio::test]
async fn test_redis() {
    let container = GenericImage::new("redis", "7.2.4")
        .with_exposed_port(6379.tcp())
        .with_wait_for(WaitFor::message_on_stdout("Ready to accept connections"))
        .with_network("bridge")
        .with_env_var("DEBUG", "1")
        .start()
        .await
        .expect("Redis started");
}

The extension traits SyncRunner and AsyncRunner each provide the method start() to start the container once it is configured.

Implementations

impl GenericImage

pub fn new<S: Into<String>>(name: S, tag: S) -> GenericImage

pub fn with_wait_for(self, wait_for: WaitFor) -> Self

pub fn with_entrypoint(self, entrypoint: &str) -> Self

pub fn with_exposed_port(self, port: ContainerPort) -> Self

Trait Implementations

impl Clone for GenericImage

fn clone(&self) -> GenericImage

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GenericImage

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

Formats the value using the given formatter.

impl Image for GenericImage

fn name(&self) -> &str

The name of the docker image to pull from the Docker Hub registry.

fn tag(&self) -> &str

Implementations are encouraged to include a tag that will not change (i.e. NOT latest) in order to prevent test code from randomly breaking because the underlying docker suddenly changed.

fn ready_conditions(&self) -> Vec<WaitFor>

Returns a list of conditions that need to be met before a started container is considered ready.

fn entrypoint(&self) -> Option<&str>

Returns the entrypoint this image needs to be created with.

fn expose_ports(&self) -> &[ContainerPort]

Returns the ports that needs to be exposed when a container is created.

fn env_vars( &self, ) -> impl IntoIterator<Item = (impl Into<Cow<'_, str>>, impl Into<Cow<'_, str>>)>

Returns the environment variables that needs to be set when a container is created.

fn mounts(&self) -> impl IntoIterator<Item = &Mount>

Returns the mounts that needs to be created when a container is created.

fn copy_to_sources(&self) -> impl IntoIterator<Item = &CopyToContainer>

Returns the files to be copied into the container at startup.

fn cmd(&self) -> impl IntoIterator<Item = impl Into<Cow<'_, str>>>

Returns the CMD this image needs to be created with.

fn exec_after_start(&self, cs: ContainerState) -> Result<Vec<ExecCommand>>

Returns the commands that needs to be executed after a container is started i.e. commands to be run in a running container.

fn exec_before_ready(&self, cs: ContainerState) -> Result<Vec<ExecCommand>>

Returns commands that will be executed after the container has started, but before the Image::ready_conditions are awaited for.