Container (TestContainers Core 1.1.9 API)

All Superinterfaces:

LinkableContainer

All Known Implementing Classes:

AmbassadorContainer, FixedHostPortGenericContainer, GenericContainer, VncRecordingSidekickContainer
```
public interface Container<SELF extends Container<SELF>>
extends LinkableContainer
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Container.ExecResult
Class to hold results from a "docker exec" command.

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Container.ExecResult` Class to hold results from a "docker exec" command.

Method Summary

All Methods Instance Methods Abstract Methods Default 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)` Adds a file system binding.
`void`	`addLink(LinkableContainer otherContainer, String alias)` Add a link to another 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()`
`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.
`List<com.github.dockerjava.api.model.Bind>`	`getBinds()`
`String[]`	`getCommandParts()`
`String`	`getContainerId()`
`com.github.dockerjava.api.command.InspectContainerResponse`	`getContainerInfo()`
`String`	`getContainerIpAddress()` Get the IP address that this container may be reached on (may not be the local machine).
`String`	`getContainerName()`
`com.github.dockerjava.api.DockerClient`	`getDockerClient()`
`com.github.dockerjava.api.model.Info`	`getDockerDaemonInfo()`
`String`	`getDockerImageName()` Get image name.
`List<String>`	`getEnv()`
`List<Integer>`	`getExposedPorts()`
`List<String>`	`getExtraHosts()`
`Future<String>`	`getImage()`
`Map<String,LinkableContainer>`	`getLinkedContainers()`
`Integer`	`getMappedPort(int originalPort)` Get the actual mapped port for a given port exposed by the container.
`List<String>`	`getPortBindings()`
`String`	`getTestHostIpAddress()` Get the IP address that containers (e.g.
`Boolean`	`isRunning()`
`default SELF`	`self()`
`void`	`setBinds(List<com.github.dockerjava.api.model.Bind> binds)`
`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`	`setCommandParts(String[] commandParts)`
`void`	`setContainerId(String containerId)`
`void`	`setContainerInfo(com.github.dockerjava.api.command.InspectContainerResponse containerInfo)`
`void`	`setContainerName(String containerName)`
`void`	`setDockerClient(com.github.dockerjava.api.DockerClient dockerClient)`
`void`	`setDockerDaemonInfo(com.github.dockerjava.api.model.Info dockerDaemonInfo)`
`void`	`setDockerImageName(String dockerImageName)` Resolve Docker image and set it.
`void`	`setEnv(List<String> env)`
`void`	`setExposedPorts(List<Integer> exposedPorts)`
`void`	`setExtraHosts(List<String> extraHosts)`
`void`	`setImage(Future<String> image)`
`void`	`setLinkedContainers(Map<String,LinkableContainer> linkedContainers)`
`void`	`setPortBindings(List<String> portBindings)`
`void`	`setWaitStrategy(WaitStrategy waitStrategy)`
`SELF`	`waitingFor(WaitStrategy waitStrategy)` Specify the `WaitStrategy` to use to determine if the container is ready.
`SELF`	`withClasspathResourceMapping(String resourcePath, String containerPath, BindMode mode)` 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`	`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`	`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`	`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.

- Method Detail
  - self
```
default SELF self()
```
    Returns:
    
    a reference to this container instance, cast to the expected generic type.
  - setCommand
```
void setCommand(@NonNull
                String command)
```
    Set the command that should be run in the container. Consider using withCommand(String) for building a container in a fluent style.
    
    Parameters:
    
    command - a command in single string format (will automatically be split on spaces)
  - setCommand
```
void setCommand(@NonNull
                String... commandParts)
```
    Set the command that should be run in the container. Consider using withCommand(String...) for building a container in a fluent style.
    
    Parameters:
    
    commandParts - a command as an array of string parts
  - addEnv
```
void addEnv(String key,
            String value)
```
    Add an environment variable to be passed to the container. Consider using withEnv(String, String) for building a container in a fluent style.
    
    Parameters:
    
    key - environment variable key
    
    value - environment variable value
  - addFileSystemBind
```
void addFileSystemBind(String hostPath,
                       String containerPath,
                       BindMode mode)
```
    Adds a file system binding. Consider using withFileSystemBind(String, String, BindMode) for building a container in a fluent style.
    
    Parameters:
    
    hostPath - the file system path on the host
    
    containerPath - the file system path inside the container
    
    mode - the bind mode
  - addLink
```
void addLink(LinkableContainer otherContainer,
             String alias)
```
    Add a link to another container.
    
    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
```
void addExposedPort(Integer port)
```
    Add an exposed port. Consider using withExposedPorts(Integer...) for building a container in a fluent style.
    
    Parameters:
    
    port - a TCP port
  - addExposedPorts
```
void addExposedPorts(int... ports)
```
    Add exposed ports. Consider using withExposedPorts(Integer...) for building a container in a fluent style.
    
    Parameters:
    
    ports - an array of TCP ports
  - waitingFor
```
SELF waitingFor(@NonNull
                WaitStrategy waitStrategy)
```
    Specify the WaitStrategy to use to determine if the container is ready.
    
    Parameters:
    
    waitStrategy - the WaitStrategy to use
    
    Returns:
    
    this
    
    See Also:
    
    Wait.defaultWaitStrategy()
  - withFileSystemBind
```
SELF withFileSystemBind(String hostPath,
                        String containerPath,
                        BindMode mode)
```
    Adds a file system binding.
    
    Parameters:
    
    hostPath - the file system path on the host
    
    containerPath - the file system path inside the container
    
    mode - the bind mode
    
    Returns:
    
    this
  - withVolumesFrom
```
SELF withVolumesFrom(Container container,
                     BindMode mode)
```
    Adds container volumes.
    
    Parameters:
    
    container - the container to add volumes from
    
    mode - the bind mode
    
    Returns:
    
    this
  - withExposedPorts
```
SELF withExposedPorts(Integer... ports)
```
    Set the ports that this container listens on
    
    Parameters:
    
    ports - an array of TCP ports
    
    Returns:
    
    this
  - withEnv
```
SELF withEnv(String key,
             String value)
```
    Add an environment variable to be passed to the container.
    
    Parameters:
    
    key - environment variable key
    
    value - environment variable value
    
    Returns:
    
    this
  - withEnv
```
SELF withEnv(Map<String,String> env)
```
    Add environment variables to be passed to the container.
    
    Parameters:
    
    env - map of environment variables
    
    Returns:
    
    this
  - withCommand
```
SELF withCommand(String cmd)
```
    Set the command that should be run in the container
    
    Parameters:
    
    cmd - a command in single string format (will automatically be split on spaces)
    
    Returns:
    
    this
  - withCommand
```
SELF withCommand(String... commandParts)
```
    Set the command that should be run in the container
    
    Parameters:
    
    commandParts - a command as an array of string parts
    
    Returns:
    
    this
  - withExtraHost
```
SELF withExtraHost(String hostname,
                   String ipAddress)
```
    Add an extra host entry to be passed to the container
    
    Parameters:
    
    hostname - hostname to use for this hosts file entry
    
    ipAddress - IP address to use for this hosts file entry
    
    Returns:
    
    this
  - withNetworkMode
```
SELF withNetworkMode(String networkMode)
```
    Set the network mode for this container, similar to the --net <name> option on the docker CLI.
    
    Parameters:
    
    networkMode - network mode, e.g. including 'host', 'bridge', 'none' or the name of an existing named network.
    
    Returns:
    
    this
  - withClasspathResourceMapping
```
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.
    
    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
  - withStartupTimeout
```
SELF withStartupTimeout(Duration startupTimeout)
```
    Set the duration of waiting time until container treated as started.
    
    Parameters:
    
    startupTimeout - timeout
    
    Returns:
    
    this
    
    See Also:
    
    WaitStrategy.waitUntilReady(GenericContainer)
  - withPrivilegedMode
```
SELF withPrivilegedMode(boolean mode)
```
    Set the privilegedMode mode for the container
    
    Parameters:
    
    mode - boolean
    
    Returns:
    
    this
  - getContainerIpAddress
```
String getContainerIpAddress()
```
    Get the IP address that this container may be reached on (may not be the local machine).
    
    Returns:
    
    an IP address
  - withMinimumRunningDuration
```
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.
    
    Parameters:
    
    minimumRunningDuration - duration this container should run for if started successfully
    
    Returns:
    
    this
  - withStartupCheckStrategy
```
SELF withStartupCheckStrategy(StartupCheckStrategy strategy)
```
    Set the startup check strategy used for checking whether the container has started.
    
    Parameters:
    
    strategy - startup check strategy
  - withWorkingDirectory
```
SELF withWorkingDirectory(String workDir)
```
    Set the working directory that the container should use on startup.
    
    Parameters:
    
    workDir - path to the working directory inside the container
  - isRunning
```
Boolean isRunning()
```
    Returns:
    
    is the container currently running?
  - getMappedPort
```
Integer getMappedPort(int originalPort)
```
    Get the actual mapped port for a given port exposed by the container.
    
    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
```
void setDockerImageName(@NonNull
                        String dockerImageName)
```
    Resolve Docker image and set it.
    
    Parameters:
    
    dockerImageName - image name
  - getDockerImageName
```
@NonNull
String getDockerImageName()
```
    Get image name.
    
    Returns:
    
    image name
  - getTestHostIpAddress
```
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.
    
    Returns:
    
    the IP address of the host machine
  - followOutput
```
void followOutput(Consumer<OutputFrame> consumer)
```
    Follow container output, sending each frame (usually, line) to a consumer. Stdout and stderr will be followed.
    
    Parameters:
    
    consumer - consumer that the frames should be sent to
  - followOutput
```
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.
    
    Parameters:
    
    consumer - consumer that the frames should be sent to
    
    types - types that should be followed (one or both of STDOUT, STDERR)
  - withLogConsumer
```
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.
    
    Parameters:
    
    consumer - consumer that output frames should be sent to
    
    Returns:
    
    this
  - fetchDockerDaemonInfo
```
com.github.dockerjava.api.model.Info fetchDockerDaemonInfo()
                                                    throws IOException
```
    Throws:
    
    IOException
  - execInContainer
```
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.
    
    Throws:
    
    UnsupportedOperationException
    
    IOException
    
    InterruptedException
    
    See Also:
    
    execInContainer(Charset, String...)
  - execInContainer
```
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.
    
    Parameters:
    
    outputCharset - the character set used to interpret the output.
    
    command - the parts of the command to run
    
    Returns:
    
    the result of execution
    
    Throws:
    
    IOException - if there's an issue communicating with Docker
    
    InterruptedException - if the thread waiting for the response is interrupted
    
    UnsupportedOperationException - if the docker daemon you're connecting to doesn't support "exec".
  - getExposedPorts
```
List<Integer> getExposedPorts()
```
  - getPortBindings
```
List<String> getPortBindings()
```
  - getExtraHosts
```
List<String> getExtraHosts()
```
  - getImage
```
Future<String> getImage()
```
  - getEnv
```
List<String> getEnv()
```
  - getCommandParts
```
String[] getCommandParts()
```
  - getBinds
```
List<com.github.dockerjava.api.model.Bind> getBinds()
```
  - getLinkedContainers
```
Map<String,LinkableContainer> getLinkedContainers()
```
  - getDockerClient
```
com.github.dockerjava.api.DockerClient getDockerClient()
```
  - getDockerDaemonInfo
```
com.github.dockerjava.api.model.Info getDockerDaemonInfo()
```
  - getContainerId
```
String getContainerId()
```
  - getContainerName
```
String getContainerName()
```
    Specified by:
    
    getContainerName in interface LinkableContainer
  - getContainerInfo
```
com.github.dockerjava.api.command.InspectContainerResponse getContainerInfo()
```
  - setExposedPorts
```
void setExposedPorts(List<Integer> exposedPorts)
```
  - setPortBindings
```
void setPortBindings(List<String> portBindings)
```
  - setExtraHosts
```
void setExtraHosts(List<String> extraHosts)
```
  - setImage
```
void setImage(Future<String> image)
```
  - setEnv
```
void setEnv(List<String> env)
```
  - setCommandParts
```
void setCommandParts(String[] commandParts)
```
  - setBinds
```
void setBinds(List<com.github.dockerjava.api.model.Bind> binds)
```
  - setLinkedContainers
```
void setLinkedContainers(Map<String,LinkableContainer> linkedContainers)
```
  - setDockerClient
```
void setDockerClient(com.github.dockerjava.api.DockerClient dockerClient)
```
  - setDockerDaemonInfo
```
void setDockerDaemonInfo(com.github.dockerjava.api.model.Info dockerDaemonInfo)
```
  - setContainerId
```
void setContainerId(String containerId)
```
  - setContainerName
```
void setContainerName(String containerName)
```
  - setWaitStrategy
```
void setWaitStrategy(WaitStrategy waitStrategy)
```
  - setContainerInfo
```
void setContainerInfo(com.github.dockerjava.api.command.InspectContainerResponse containerInfo)
```

Interface Container<SELF extends Container<SELF>>

Nested Class Summary

Method Summary

Method Detail

self

setCommand

setCommand

addEnv

addFileSystemBind

addLink

addExposedPort

addExposedPorts

waitingFor

withFileSystemBind

withVolumesFrom

withExposedPorts

withEnv

withEnv

withCommand

withCommand

withExtraHost

withNetworkMode

withClasspathResourceMapping

withStartupTimeout

withPrivilegedMode

getContainerIpAddress

withMinimumRunningDuration

withStartupCheckStrategy

withWorkingDirectory

isRunning

getMappedPort

setDockerImageName

getDockerImageName

getTestHostIpAddress

followOutput

followOutput

withLogConsumer

fetchDockerDaemonInfo

execInContainer

execInContainer

getExposedPorts

getPortBindings

getExtraHosts

getImage

getEnv

getCommandParts

getBinds

getLinkedContainers

getDockerClient

getDockerDaemonInfo

getContainerId

getContainerName

getContainerInfo

setExposedPorts

setPortBindings

setExtraHosts

setImage

setEnv

setCommandParts

setBinds

setLinkedContainers

setDockerClient

setDockerDaemonInfo

setContainerId

setContainerName

setWaitStrategy

setContainerInfo