GenericContainer (TestContainers Core 1.6.0 API)

java.lang.Object
- org.testcontainers.containers.FailureDetectingExternalResource
- - org.testcontainers.containers.GenericContainer<SELF>

All Implemented Interfaces:

AutoCloseable, org.junit.rules.TestRule, Container<SELF>, LinkableContainer

Direct Known Subclasses:

AmbassadorContainer, FixedHostPortGenericContainer, SocatContainer, VncRecordingContainer, VncRecordingSidekickContainer
```
public class GenericContainer<SELF extends GenericContainer<SELF>>
extends FailureDetectingExternalResource
implements Container<SELF>, AutoCloseable
```
Base class for that allows a container to be launched and controlled.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class GenericContainer.AbstractWaitStrategy
Convenience class with access to non-public members of GenericContainer.
- Nested classes/interfaces inherited from interface org.testcontainers.containers.Container
  Container.ExecResult

Nested Classes
Modifier and Type	Class and Description
`static class`	`GenericContainer.AbstractWaitStrategy` Convenience class with access to non-public members of GenericContainer.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CONTAINER_RUNNING_TIMEOUT_SEC`
`protected String`	`containerId`
`protected String`	`containerName`
`protected com.github.dockerjava.api.DockerClient`	`dockerClient`
`protected com.github.dockerjava.api.model.Info`	`dockerDaemonInfo`
`protected WaitStrategy`	`waitStrategy` The approach to determine if the container is ready.

Constructor Summary

Constructors
Constructor and Description

GenericContainer()

GenericContainer(Future<String> image)

GenericContainer(String dockerImageName)

Constructors
Constructor and Description
`GenericContainer()`
`GenericContainer(Future<String> image)`
`GenericContainer(String dockerImageName)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addEnv(String key, String value)` Add an environment variable to be passed to the container.
`void`	`addExposedPort(Integer port)` Add an exposed port.
`void`	`addExposedPorts(int... ports)` Add exposed ports.
`void`	`addFileSystemBind(String hostPath, String containerPath, BindMode mode, SelinuxContext selinuxContext)` Adds a file system binding.
`protected void`	`addFixedExposedPort(int hostPort, int containerPort)` Add a container port that should be bound to a fixed port on the docker host.
`void`	`addLink(LinkableContainer otherContainer, String alias)` Deprecated. Links are deprecated (see #465). Please use `Network` features instead.
`void`	`close()`
`protected void`	`configure()`
`protected void`	`containerIsStarted(com.github.dockerjava.api.command.InspectContainerResponse containerInfo)`
`protected void`	`containerIsStarting(com.github.dockerjava.api.command.InspectContainerResponse containerInfo)`
`void`	`copyFileFromContainer(String containerPath, String destinationPath)` Copies a file which resides inside the container to user defined directory
`void`	`copyFileToContainer(MountableFile mountableLocalFile, String containerPath)` Copies a file which resides inside the classpath to the container.
`protected Path`	`createVolumeDirectory(boolean temporary)` Creates a directory on the local filesystem which will be mounted as a volume for the container.
`Container.ExecResult`	`execInContainer(Charset outputCharset, String... command)` Run a command inside a running container, as though using "docker exec".
`Container.ExecResult`	`execInContainer(String... command)` Run a command inside a running container, as though using "docker exec", and interpreting the output as UTF8.
`com.github.dockerjava.api.model.Info`	`fetchDockerDaemonInfo()`
`protected void`	`finished(org.junit.runner.Description description)`
`void`	`followOutput(Consumer<OutputFrame> consumer)` Follow container output, sending each frame (usually, line) to a consumer.
`void`	`followOutput(Consumer<OutputFrame> consumer, OutputFrame.OutputType... types)` Follow container output, sending each frame (usually, line) to a consumer.
`String`	`getContainerIpAddress()` Get the IP address that this container may be reached on (may not be the local machine).
`String`	`getDockerImageName()` Get image name.
`List<String>`	`getEnv()`
`Map<String,String>`	`getEnvMap()`
`String`	`getIpAddress()` Deprecated. please use getContainerIpAddress() instead
`protected Integer`	`getLivenessCheckPort()` Deprecated. see `getLivenessCheckPorts()` for replacement
`protected Set<Integer>`	`getLivenessCheckPorts()`
`Integer`	`getMappedPort(int originalPort)` Get the actual mapped port for a given port exposed by the container.
`String`	`getTestHostIpAddress()` Get the IP address that containers (e.g.
`protected WaitStrategy`	`getWaitStrategy()` The `WaitStrategy` to use to determine if the container is ready.
`Boolean`	`isRunning()`
`protected org.slf4j.Logger`	`logger()` Provide a logger that references the docker image name.
`void`	`setCommand(String... commandParts)` Set the command that should be run in the container.
`void`	`setCommand(String command)` Set the command that should be run in the container.
`void`	`setDockerImageName(String dockerImageName)` Resolve Docker image and set it.
`void`	`setEnv(List<String> env)`
`void`	`start()` Starts the container using docker, pulling an image if necessary.
`protected void`	`starting(org.junit.runner.Description description)`
`void`	`stop()` Stops the container.
`SELF`	`waitingFor(WaitStrategy waitStrategy)` Specify the `WaitStrategy` to use to determine if the container is ready.
`protected void`	`waitUntilContainerStarted()` Wait until the container has started.
`SELF`	`withClasspathResourceMapping(String resourcePath, String containerPath, BindMode mode)` Map a resource (file or directory) on the classpath to a path inside the container.
`SELF`	`withClasspathResourceMapping(String resourcePath, String containerPath, BindMode mode, SelinuxContext selinuxContext)` Map a resource (file or directory) on the classpath to a path inside the container.
`SELF`	`withCommand(String... commandParts)` Set the command that should be run in the container
`SELF`	`withCommand(String cmd)` Set the command that should be run in the container
`SELF`	`withCreateContainerCmdModifier(Consumer<com.github.dockerjava.api.command.CreateContainerCmd> modifier)` Allow low level modifications of `CreateContainerCmd` after it was pre-configured in `tryStart(Profiler)`.
`SELF`	`withEnv(Map<String,String> env)` Add environment variables to be passed to the container.
`SELF`	`withEnv(String key, String value)` Add an environment variable to be passed to the container.
`SELF`	`withExposedPorts(Integer... ports)` Set the ports that this container listens on
`SELF`	`withExtraHost(String hostname, String ipAddress)` Add an extra host entry to be passed to the container
`SELF`	`withFileSystemBind(String hostPath, String containerPath, BindMode mode)` Adds a file system binding.
`SELF`	`withLogConsumer(Consumer<OutputFrame> consumer)` Attach an output consumer at container startup, enabling stdout and stderr to be followed, waited on, etc.
`SELF`	`withMinimumRunningDuration(Duration minimumRunningDuration)` Only consider a container to have successfully started if it has been running for this duration.
`SELF`	`withNetwork(Network network)` Set the network for this container, similar to the `--network <name>` option on the docker CLI.
`SELF`	`withNetworkAliases(String... aliases)` Set the network aliases for this container, similar to the `--network-alias <my-service>` option on the docker CLI.
`SELF`	`withNetworkMode(String networkMode)` Set the network mode for this container, similar to the `--net <name>` option on the docker CLI.
`SELF`	`withPrivilegedMode(boolean mode)` Set the privilegedMode mode for the container
`SELF`	`withStartupAttempts(int attempts)` Allow container startup to be attempted more than once if an error occurs.
`SELF`	`withStartupCheckStrategy(StartupCheckStrategy strategy)` Set the startup check strategy used for checking whether the container has started.
`SELF`	`withStartupTimeout(Duration startupTimeout)` Set the duration of waiting time until container treated as started.
`SELF`	`withVolumesFrom(Container container, BindMode mode)` Adds container volumes.
`SELF`	`withWorkingDirectory(String workDir)` Set the working directory that the container should use on startup.

Methods inherited from class org.testcontainers.containers.FailureDetectingExternalResource
apply, failed, succeeded

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.testcontainers.containers.Container
addFileSystemBind, getBinds, getCommandParts, getContainerId, getContainerInfo, getContainerName, getDockerClient, getDockerDaemonInfo, getExposedPorts, getExtraHosts, getFirstMappedPort, getImage, getLinkedContainers, getPortBindings, self, setBinds, setCommandParts, setExposedPorts, setExtraHosts, setImage, setLinkedContainers, setPortBindings, setWaitStrategy, withEnv, withFileSystemBind

- Field Detail
  - CONTAINER_RUNNING_TIMEOUT_SEC
```
public static final int CONTAINER_RUNNING_TIMEOUT_SEC
```
    See Also:
    
    Constant Field Values
  - dockerClient
```
protected com.github.dockerjava.api.DockerClient dockerClient
```
  - dockerDaemonInfo
```
protected com.github.dockerjava.api.model.Info dockerDaemonInfo
```
  - containerId
```
protected String containerId
```
  - containerName
```
protected String containerName
```
  - waitStrategy
```
@NonNull
protected WaitStrategy waitStrategy
```
    The approach to determine if the container is ready.
- Constructor Detail
  - GenericContainer
```
public GenericContainer()
```
  - GenericContainer
```
public GenericContainer(@NonNull
                        String dockerImageName)
```
  - GenericContainer
```
public GenericContainer(@NonNull
                        Future<String> image)
```
- Method Detail
  - start
```
public void start()
```
    Starts the container using docker, pulling an image if necessary.
  - stop
```
public void stop()
```
    Stops the container.
  - logger
```
protected org.slf4j.Logger logger()
```
    Provide a logger that references the docker image name.
    
    Returns:
    
    a logger that references the docker image name
  - createVolumeDirectory
```
protected Path createVolumeDirectory(boolean temporary)
```
    Creates a directory on the local filesystem which will be mounted as a volume for the container.
    
    Parameters:
    
    temporary - is the volume directory temporary? If true, the directory will be deleted on JVM shutdown.
    
    Returns:
    
    path to the volume directory
  - configure
```
protected void configure()
```
  - containerIsStarting
```
protected void containerIsStarting(com.github.dockerjava.api.command.InspectContainerResponse containerInfo)
```
  - containerIsStarted
```
protected void containerIsStarted(com.github.dockerjava.api.command.InspectContainerResponse containerInfo)
```
  - getLivenessCheckPort
```
@Deprecated
protected Integer getLivenessCheckPort()
```
    Deprecated. see getLivenessCheckPorts() for replacement
    
    Returns:
    
    the port on which to check if the container is ready
  - getLivenessCheckPorts
```
@NotNull
 @NonNull
protected Set<Integer> getLivenessCheckPorts()
```
    Returns:
    
    the ports on which to check if the container is ready
  - waitingFor
```
public SELF waitingFor(@NonNull
                       WaitStrategy waitStrategy)
```
    Specify the WaitStrategy to use to determine if the container is ready.
    
    Specified by:
    
    waitingFor in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    waitStrategy - the WaitStrategy to use
    
    Returns:
    
    this
    
    See Also:
    
    Wait.defaultWaitStrategy()
  - getWaitStrategy
```
protected WaitStrategy getWaitStrategy()
```
    The WaitStrategy to use to determine if the container is ready. Defaults to Wait.defaultWaitStrategy().
    
    Returns:
    
    the WaitStrategy to use
  - waitUntilContainerStarted
```
protected void waitUntilContainerStarted()
```
    Wait until the container has started. The default implementation simply waits for a port to start listening; other implementations are available as implementations of WaitStrategy
    
    See Also:
    
    waitingFor(WaitStrategy)
  - setCommand
```
public void setCommand(@NonNull
                       String command)
```
    Set the command that should be run in the container. Consider using Container.withCommand(String) for building a container in a fluent style.
    
    Specified by:
    
    setCommand in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    command - a command in single string format (will automatically be split on spaces)
  - setCommand
```
public void setCommand(@NonNull
                       String... commandParts)
```
    Set the command that should be run in the container. Consider using Container.withCommand(String...) for building a container in a fluent style.
    
    Specified by:
    
    setCommand in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    commandParts - a command as an array of string parts
  - getEnvMap
```
public Map<String,String> getEnvMap()
```
    Specified by:
    
    getEnvMap in interface Container<SELF extends GenericContainer<SELF>>
  - getEnv
```
public List<String> getEnv()
```
    Specified by:
    
    getEnv in interface Container<SELF extends GenericContainer<SELF>>
  - setEnv
```
public void setEnv(List<String> env)
```
    Specified by:
    
    setEnv in interface Container<SELF extends GenericContainer<SELF>>
  - addEnv
```
public void addEnv(String key,
                   String value)
```
    Add an environment variable to be passed to the container. Consider using Container.withEnv(String, String) for building a container in a fluent style.
    
    Specified by:
    
    addEnv in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    key - environment variable key
    
    value - environment variable value
  - addFileSystemBind
```
public void addFileSystemBind(String hostPath,
                              String containerPath,
                              BindMode mode,
                              SelinuxContext selinuxContext)
```
    Adds a file system binding. Consider using Container.withFileSystemBind(String, String, BindMode) for building a container in a fluent style.
    
    Specified by:
    
    addFileSystemBind in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    hostPath - the file system path on the host
    
    containerPath - the file system path inside the container
    
    mode - the bind mode
    
    selinuxContext - selinux context argument to use for this file
  - withFileSystemBind
```
public SELF withFileSystemBind(String hostPath,
                               String containerPath,
                               BindMode mode)
```
    Adds a file system binding.
    
    Specified by:
    
    withFileSystemBind in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    hostPath - the file system path on the host
    
    containerPath - the file system path inside the container
    
    mode - the bind mode
    
    Returns:
    
    this
  - withVolumesFrom
```
public SELF withVolumesFrom(Container container,
                            BindMode mode)
```
    Adds container volumes.
    
    Specified by:
    
    withVolumesFrom in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    container - the container to add volumes from
    
    mode - the bind mode
    
    Returns:
    
    this
  - addLink
```
@Deprecated
public void addLink(LinkableContainer otherContainer,
                                String alias)
```
    Deprecated. Links are deprecated (see #465). Please use Network features instead.
    
    Description copied from interface: Container
    
    Add a link to another container.
    
    Specified by:
    
    addLink in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    otherContainer - the other container object to link to
    
    alias - the alias (for the other container) that this container should be able to use
  - addExposedPort
```
public void addExposedPort(Integer port)
```
    Description copied from interface: Container
    
    Add an exposed port. Consider using Container.withExposedPorts(Integer...) for building a container in a fluent style.
    
    Specified by:
    
    addExposedPort in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    port - a TCP port
  - addExposedPorts
```
public void addExposedPorts(int... ports)
```
    Description copied from interface: Container
    
    Add exposed ports. Consider using Container.withExposedPorts(Integer...) for building a container in a fluent style.
    
    Specified by:
    
    addExposedPorts in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    ports - an array of TCP ports
  - starting
```
protected void starting(org.junit.runner.Description description)
```
    Overrides:
    
    starting in class FailureDetectingExternalResource
  - finished
```
protected void finished(org.junit.runner.Description description)
```
    Overrides:
    
    finished in class FailureDetectingExternalResource
  - withExposedPorts
```
public SELF withExposedPorts(Integer... ports)
```
    Set the ports that this container listens on
    
    Specified by:
    
    withExposedPorts in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    ports - an array of TCP ports
    
    Returns:
    
    this
  - addFixedExposedPort
```
protected void addFixedExposedPort(int hostPort,
                                   int containerPort)
```
    Add a container port that should be bound to a fixed port on the docker host.
    Note that this method is protected scope to discourage use, as clashes or instability are more likely when using fixed port mappings. If you need to use this method from a test, please use FixedHostPortGenericContainer instead of GenericContainer.
    
    Parameters:
    
    hostPort -
    
    containerPort -
  - withEnv
```
public SELF withEnv(String key,
                    String value)
```
    Add an environment variable to be passed to the container.
    
    Specified by:
    
    withEnv in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    key - environment variable key
    
    value - environment variable value
    
    Returns:
    
    this
  - withEnv
```
public SELF withEnv(Map<String,String> env)
```
    Add environment variables to be passed to the container.
    
    Specified by:
    
    withEnv in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    env - map of environment variables
    
    Returns:
    
    this
  - withCommand
```
public SELF withCommand(String cmd)
```
    Set the command that should be run in the container
    
    Specified by:
    
    withCommand in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    cmd - a command in single string format (will automatically be split on spaces)
    
    Returns:
    
    this
  - withCommand
```
public SELF withCommand(String... commandParts)
```
    Set the command that should be run in the container
    
    Specified by:
    
    withCommand in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    commandParts - a command as an array of string parts
    
    Returns:
    
    this
  - withExtraHost
```
public SELF withExtraHost(String hostname,
                          String ipAddress)
```
    Add an extra host entry to be passed to the container
    
    Specified by:
    
    withExtraHost in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    hostname - hostname to use for this hosts file entry
    
    ipAddress - IP address to use for this hosts file entry
    
    Returns:
    
    this
  - withNetworkMode
```
public SELF withNetworkMode(String networkMode)
```
    Description copied from interface: Container
    
    Set the network mode for this container, similar to the --net <name> option on the docker CLI.
    
    Specified by:
    
    withNetworkMode in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    networkMode - network mode, e.g. including 'host', 'bridge', 'none' or the name of an existing named network.
    
    Returns:
    
    this
  - withNetwork
```
public SELF withNetwork(Network network)
```
    Description copied from interface: Container
    
    Set the network for this container, similar to the --network <name> option on the docker CLI.
    
    Specified by:
    
    withNetwork in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    network - the instance of Network
    
    Returns:
    
    this
  - withNetworkAliases
```
public SELF withNetworkAliases(String... aliases)
```
    Description copied from interface: Container
    
    Set the network aliases for this container, similar to the --network-alias <my-service> option on the docker CLI.
    
    Specified by:
    
    withNetworkAliases in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    aliases - the list of aliases
    
    Returns:
    
    this
  - withClasspathResourceMapping
```
public SELF withClasspathResourceMapping(String resourcePath,
                                         String containerPath,
                                         BindMode mode)
```
    Map a resource (file or directory) on the classpath to a path inside the container. This will only work if you are running your tests outside a Docker container.
    
    Specified by:
    
    withClasspathResourceMapping in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    resourcePath - path to the resource on the classpath (relative to the classpath root; should not start with a leading slash)
    
    containerPath - path this should be mapped to inside the container
    
    mode - access mode for the file
    
    Returns:
    
    this
  - withClasspathResourceMapping
```
public SELF withClasspathResourceMapping(String resourcePath,
                                         String containerPath,
                                         BindMode mode,
                                         SelinuxContext selinuxContext)
```
    Map a resource (file or directory) on the classpath to a path inside the container. This will only work if you are running your tests outside a Docker container.
    
    Specified by:
    
    withClasspathResourceMapping in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    resourcePath - path to the resource on the classpath (relative to the classpath root; should not start with a leading slash)
    
    containerPath - path this should be mapped to inside the container
    
    mode - access mode for the file
    
    selinuxContext - selinux context argument to use for this file
    
    Returns:
    
    this
  - withStartupTimeout
```
public SELF withStartupTimeout(Duration startupTimeout)
```
    Set the duration of waiting time until container treated as started.
    
    Specified by:
    
    withStartupTimeout in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    startupTimeout - timeout
    
    Returns:
    
    this
    
    See Also:
    
    WaitStrategy.waitUntilReady(GenericContainer)
  - withPrivilegedMode
```
public SELF withPrivilegedMode(boolean mode)
```
    Description copied from interface: Container
    
    Set the privilegedMode mode for the container
    
    Specified by:
    
    withPrivilegedMode in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    mode - boolean
    
    Returns:
    
    this
  - getContainerIpAddress
```
public String getContainerIpAddress()
```
    Get the IP address that this container may be reached on (may not be the local machine).
    
    Specified by:
    
    getContainerIpAddress in interface Container<SELF extends GenericContainer<SELF>>
    
    Returns:
    
    an IP address
  - withMinimumRunningDuration
```
public SELF withMinimumRunningDuration(Duration minimumRunningDuration)
```
    Only consider a container to have successfully started if it has been running for this duration. The default value is null; if that's the value, ignore this check.
    
    Specified by:
    
    withMinimumRunningDuration in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    minimumRunningDuration - duration this container should run for if started successfully
    
    Returns:
    
    this
  - withStartupCheckStrategy
```
public SELF withStartupCheckStrategy(StartupCheckStrategy strategy)
```
    Set the startup check strategy used for checking whether the container has started.
    
    Specified by:
    
    withStartupCheckStrategy in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    strategy - startup check strategy
  - withWorkingDirectory
```
public SELF withWorkingDirectory(String workDir)
```
    Set the working directory that the container should use on startup.
    
    Specified by:
    
    withWorkingDirectory in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    workDir - path to the working directory inside the container
  - getIpAddress
```
@Deprecated
public String getIpAddress()
```
    Deprecated. please use getContainerIpAddress() instead
    
    Get the IP address that this container may be reached on (may not be the local machine).
    
    Returns:
    
    an IP address
  - isRunning
```
public Boolean isRunning()
```
    Specified by:
    
    isRunning in interface Container<SELF extends GenericContainer<SELF>>
    
    Returns:
    
    is the container currently running?
  - getMappedPort
```
public Integer getMappedPort(int originalPort)
```
    Get the actual mapped port for a given port exposed by the container.
    
    Specified by:
    
    getMappedPort in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    originalPort - the original TCP port that is exposed
    
    Returns:
    
    the port that the exposed port is mapped to, or null if it is not exposed
  - setDockerImageName
```
public void setDockerImageName(@NonNull
                               String dockerImageName)
```
    Resolve Docker image and set it.
    
    Specified by:
    
    setDockerImageName in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    dockerImageName - image name
  - getDockerImageName
```
@NonNull
public String getDockerImageName()
```
    Get image name.
    
    Specified by:
    
    getDockerImageName in interface Container<SELF extends GenericContainer<SELF>>
    
    Returns:
    
    image name
  - getTestHostIpAddress
```
public String getTestHostIpAddress()
```
    Get the IP address that containers (e.g. browsers) can use to reference a service running on the local machine, i.e. the machine on which this test is running.
    For example, if a web server is running on port 8080 on this local machine, the containerized web driver needs to be pointed at "http://" + getTestHostIpAddress() + ":8080" in order to access it. Trying to hit localhost from inside the container is not going to work, since the container has its own IP address.
    
    Specified by:
    
    getTestHostIpAddress in interface Container<SELF extends GenericContainer<SELF>>
    
    Returns:
    
    the IP address of the host machine
  - followOutput
```
public void followOutput(Consumer<OutputFrame> consumer)
```
    Follow container output, sending each frame (usually, line) to a consumer. Stdout and stderr will be followed.
    
    Specified by:
    
    followOutput in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    consumer - consumer that the frames should be sent to
  - followOutput
```
public void followOutput(Consumer<OutputFrame> consumer,
                         OutputFrame.OutputType... types)
```
    Follow container output, sending each frame (usually, line) to a consumer. This method allows Stdout and/or stderr to be selected.
    
    Specified by:
    
    followOutput in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    consumer - consumer that the frames should be sent to
    
    types - types that should be followed (one or both of STDOUT, STDERR)
  - withLogConsumer
```
public SELF withLogConsumer(Consumer<OutputFrame> consumer)
```
    Attach an output consumer at container startup, enabling stdout and stderr to be followed, waited on, etc.
    More than one consumer may be registered.
    
    Specified by:
    
    withLogConsumer in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    consumer - consumer that output frames should be sent to
    
    Returns:
    
    this
  - fetchDockerDaemonInfo
```
public com.github.dockerjava.api.model.Info fetchDockerDaemonInfo()
                                                           throws IOException
```
    Specified by:
    
    fetchDockerDaemonInfo in interface Container<SELF extends GenericContainer<SELF>>
    
    Throws:
    
    IOException
  - execInContainer
```
public Container.ExecResult execInContainer(String... command)
                                     throws UnsupportedOperationException,
                                            IOException,
                                            InterruptedException
```
    Run a command inside a running container, as though using "docker exec", and interpreting the output as UTF8.
    
    Specified by:
    
    execInContainer in interface Container<SELF extends GenericContainer<SELF>>
    
    Throws:
    
    UnsupportedOperationException
    
    IOException
    
    InterruptedException
    
    See Also:
    
    Container.execInContainer(Charset, String...)
  - copyFileToContainer
```
public void copyFileToContainer(MountableFile mountableLocalFile,
                                String containerPath)
```
    Copies a file which resides inside the classpath to the container.
    
    Specified by:
    
    copyFileToContainer in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    mountableLocalFile - file which is copied into the container
    
    containerPath - destination path inside the container
  - copyFileFromContainer
```
public void copyFileFromContainer(String containerPath,
                                  String destinationPath)
                           throws IOException
```
    Copies a file which resides inside the container to user defined directory
    
    Specified by:
    
    copyFileFromContainer in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    containerPath - path to file which is copied from container
    
    destinationPath - destination path to which file is copied with file name
    
    Throws:
    
    IOException - if there's an issue communicating with Docker or receiving entry from TarArchiveInputStream
  - execInContainer
```
public Container.ExecResult execInContainer(Charset outputCharset,
                                            String... command)
                                     throws UnsupportedOperationException,
                                            IOException,
                                            InterruptedException
```
    Run a command inside a running container, as though using "docker exec".
    This functionality is not available on a docker daemon running the older "lxc" execution driver. At the time of writing, CircleCI was using this driver.
    
    Specified by:
    
    execInContainer in interface Container<SELF extends GenericContainer<SELF>>
    
    Parameters:
    
    outputCharset - the character set used to interpret the output.
    
    command - the parts of the command to run
    
    Returns:
    
    the result of execution
    
    Throws:
    
    UnsupportedOperationException - if the docker daemon you're connecting to doesn't support "exec".
    
    IOException - if there's an issue communicating with Docker
    
    InterruptedException - if the thread waiting for the response is interrupted
  - withStartupAttempts
```
public SELF withStartupAttempts(int attempts)
```
    Allow container startup to be attempted more than once if an error occurs. To be if containers are 'flaky' but this flakiness is not something that should affect test outcomes.
    
    Parameters:
    
    attempts - number of attempts
  - close
```
public void close()
```
    Specified by:
    
    close in interface AutoCloseable
  - withCreateContainerCmdModifier
```
public SELF withCreateContainerCmdModifier(Consumer<com.github.dockerjava.api.command.CreateContainerCmd> modifier)
```
    Allow low level modifications of CreateContainerCmd after it was pre-configured in tryStart(Profiler). Invocation happens eagerly on a moment when container is created. Warning: this does expose the underlying docker-java API so might change outside of our control.
    
    Parameters:
    
    modifier - Consumer of CreateContainerCmd.
    
    Returns:
    
    this

Class GenericContainer<SELF extends GenericContainer<SELF>>

Nested Class Summary

Nested classes/interfaces inherited from interface org.testcontainers.containers.Container

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.testcontainers.containers.FailureDetectingExternalResource

Methods inherited from class java.lang.Object

Methods inherited from interface org.testcontainers.containers.Container

Field Detail

CONTAINER_RUNNING_TIMEOUT_SEC

dockerClient

dockerDaemonInfo

containerId

containerName

waitStrategy

Constructor Detail

GenericContainer

GenericContainer

GenericContainer

Method Detail

start

stop

logger

createVolumeDirectory

configure

containerIsStarting

containerIsStarted

getLivenessCheckPort

getLivenessCheckPorts

waitingFor

getWaitStrategy

waitUntilContainerStarted

setCommand

setCommand

getEnvMap

getEnv

setEnv

addEnv

addFileSystemBind

withFileSystemBind

withVolumesFrom

addLink

addExposedPort

addExposedPorts

starting

finished

withExposedPorts

addFixedExposedPort

withEnv

withEnv

withCommand

withCommand

withExtraHost

withNetworkMode

withNetwork

withNetworkAliases

withClasspathResourceMapping

withClasspathResourceMapping

withStartupTimeout

withPrivilegedMode

getContainerIpAddress

withMinimumRunningDuration

withStartupCheckStrategy

withWorkingDirectory

getIpAddress

isRunning

getMappedPort

setDockerImageName

getDockerImageName

getTestHostIpAddress

followOutput

followOutput

withLogConsumer

fetchDockerDaemonInfo

execInContainer

copyFileToContainer

copyFileFromContainer

execInContainer

withStartupAttempts