How to create a container¶
Testcontainers are a wrapper around the Docker daemon designed for tests. Anything you can run in Docker, you can spin up with Testcontainers and integrate into your tests:
- NoSQL databases or other data stores (e.g. Redis, ElasticSearch, MongoDB)
- Web servers/proxies (e.g. NGINX, Apache)
- Log services (e.g. Logstash, Kibana)
- Other services developed by your team/organization which are already dockerized
Run¶
- Since v0.37.0
testcontainers.Run
defines the container that should be run, similar to the docker run
command.
func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*DockerContainer, error)
context.Context
, the Go context.string
, the Docker image to use.testcontainers.ContainerCustomizer
, a variadic argument for passing options.
The following test creates an NGINX container on both the bridge
(docker default
network) and the foo
network and validates that it returns 200 for the status code.
It also demonstrates how to use CleanupContainer
, that ensures that nginx container
is removed when the test ends even if the underlying container errored,
as well as the CleanupNetwork
which does the same for networks.
The alternatives for these outside of tests as a defer
are TerminateContainer
and Network.Remove
which can be seen in the examples.
ctx := context.Background()
nw, err := network.New(ctx)
if err != nil {
log.Printf("failed to create network: %s", err)
return
}
defer func() {
if err := nw.Remove(ctx); err != nil {
log.Printf("failed to remove network: %s", err)
}
}()
testFileContent := "Hello from file!"
ctr, err := testcontainers.Run(
ctx,
"nginx:alpine",
network.WithNetwork([]string{"nginx-alias"}, nw),
testcontainers.WithFiles(testcontainers.ContainerFile{
Reader: strings.NewReader(testFileContent),
ContainerFilePath: "/tmp/file.txt",
FileMode: 0o644,
}),
testcontainers.WithTmpfs(map[string]string{
"/tmp": "rw",
}),
testcontainers.WithLabels(map[string]string{
"testcontainers.label": "true",
}),
testcontainers.WithEnv(map[string]string{
"TEST": "true",
}),
testcontainers.WithExposedPorts("80/tcp"),
testcontainers.WithAfterReadyCommand(testcontainers.NewRawCommand([]string{"echo", "hello", "world"})),
testcontainers.WithWaitStrategy(wait.ForListeningPort("80/tcp").WithStartupTimeout(time.Second*5)),
)
defer func() {
if err := testcontainers.TerminateContainer(ctr); err != nil {
log.Printf("failed to terminate container: %s", err)
}
}()
if err != nil {
log.Printf("failed to start container: %s", err)
return
}
state, err := ctr.State(ctx)
if err != nil {
log.Printf("failed to get container state: %s", err)
return
}
fmt.Println(state.Running)
cli, err := testcontainers.NewDockerClientWithOpts(ctx)
if err != nil {
log.Printf("failed to create docker client: %s", err)
return
}
ctrResp, err := cli.ContainerInspect(ctx, ctr.GetContainerID())
if err != nil {
log.Printf("failed to inspect container: %s", err)
return
}
// networks
respNw, ok := ctrResp.NetworkSettings.Networks[nw.Name]
if !ok {
log.Printf("network not found")
return
}
fmt.Println(respNw.Aliases)
// env
fmt.Println(ctrResp.Config.Env[0])
// tmpfs
tmpfs, ok := ctrResp.HostConfig.Tmpfs["/tmp"]
if !ok {
log.Printf("tmpfs not found")
return
}
fmt.Println(tmpfs)
// labels
fmt.Println(ctrResp.Config.Labels["testcontainers.label"])
// files
f, err := ctr.CopyFileFromContainer(ctx, "/tmp/file.txt")
if err != nil {
log.Printf("failed to copy file from container: %s", err)
return
}
content, err := io.ReadAll(f)
if err != nil {
log.Printf("failed to read file: %s", err)
return
}
fmt.Println(string(content))
// Output:
// true
// [nginx-alias]
// TEST=true
// rw
// true
// Hello from file!
Customizing the container¶
Basic Options¶
WithExposedPorts¶
- Since v0.37.0
If you need to expose additional ports from the container, you can use testcontainers.WithExposedPorts
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithExposedPorts("8080/tcp", "9090/tcp"))
WithEnv¶
- Since v0.29.0
If you need to either pass additional environment variables to a container or override them, you can use testcontainers.WithEnv
for example:
ctr, err = mymodule.Run(ctx, "docker.io/myservice:1.2.3", testcontainers.WithEnv(map[string]string{"FOO": "BAR"}))
WithWaitStrategy¶
- Since v0.20.0
If you need to set a different wait strategy for the container, you can use testcontainers.WithWaitStrategy
with a valid wait strategy.
Info
The default deadline for the wait strategy is 60 seconds.
WithWaitStrategyAndDeadline¶
- Since v0.20.0
At the same time, it's possible to set a wait strategy and a custom deadline with testcontainers.WithWaitStrategyAndDeadline
.
WithAdditionalWaitStrategy¶
- Not available until the next release main
If you need to add a wait strategy to the existing wait strategy, you can use testcontainers.WithAdditionalWaitStrategy
.
Info
The default deadline for the wait strategy is 60 seconds.
WithAdditionalWaitStrategyAndDeadline¶
-
- Not available until the next release main
At the same time, it's possible to add a wait strategy and a custom deadline with testcontainers.WithAdditionalWaitStrategyAndDeadline
.
WithEntrypoint¶
- Since v0.37.0
If you need to completely replace the container's entrypoint, you can use testcontainers.WithEntrypoint
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithEntrypoint("/bin/sh", "-c", "echo hello"))
WithEntrypointArgs¶
- Since v0.37.0
If you need to append commands to the container's entrypoint, you can use testcontainers.WithEntrypointArgs
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithEntrypointArgs("echo", "hello"))
WithCmd¶
- Since v0.37.0
If you need to completely replace the container's command, you can use testcontainers.WithCmd
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithCmd("echo", "hello"))
WithCmdArgs¶
- Since v0.37.0
If you need to append commands to the container's command, you can use testcontainers.WithCmdArgs
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithCmdArgs("echo", "hello"))
WithLabels¶
- Since v0.37.0
If you need to add Docker labels to the container, you can use testcontainers.WithLabels
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithLabels(map[string]string{
"environment": "testing",
"project": "myapp",
}))
Lifecycle Options¶
WithLifecycleHooks¶
- Not available until the next release main
If you need to set the lifecycle hooks for the container, you can use testcontainers.WithLifecycleHooks
, which replaces the existing lifecycle hooks with the new ones.
WithAdditionalLifecycleHooks¶
- Not available until the next release main
You can also use testcontainers.WithAdditionalLifecycleHooks
, which appends the new lifecycle hooks to the existing ones.
WithStartupCommand¶
- Since v0.25.0
Testcontainers exposes the WithStartupCommand(e ...Executable)
option to run arbitrary commands in the container right after it's started.
Info
To better understand how this feature works, please read the Create containers: Lifecycle Hooks documentation.
It also exports an Executable
interface, defining the following methods:
AsCommand()
, which returns a slice of strings to represent the command and positional arguments to be executed in the container;Options()
, which returns the slice of functional options with the Docker's ExecConfigs used to create the command in the container (the working directory, environment variables, user executing the command, etc) and the possible output format (Multiplexed).
You could use this feature to run a custom script, or to run a command that is not supported by the module right after the container is started.
WithAfterReadyCommand¶
- Since v0.28.0
Testcontainers exposes the WithAfterReadyCommand(e ...Executable)
option to run arbitrary commands in the container right after it's ready, which happens when the defined wait strategies have finished with success.
Info
To better understand how this feature works, please read the Create containers: Lifecycle Hooks documentation.
It leverages the Executable
interface to represent the command and positional arguments to be executed in the container.
You could use this feature to run a custom script, or to run a command that is not supported by the module right after the container is ready.
Files & Mounts Options¶
WithFiles¶
- Since v0.37.0
If you need to copy files into the container, you can use testcontainers.WithFiles
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithFiles([]testcontainers.ContainerFile{
{
HostFilePath: "/path/to/local/file.txt",
ContainerFilePath: "/container/file.txt",
FileMode: 0o644,
},
}))
This option allows you to copy files from the host into the container at creation time.
WithMounts¶
- Since v0.37.0
If you need to add volume mounts to the container, you can use testcontainers.WithMounts
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithMounts([]testcontainers.ContainerMount{
{
Source: testcontainers.GenericVolumeMountSource{Name: "appdata"},
Target: "/app/data",
},
}))
WithTmpfs¶
- Since v0.37.0
If you need to add tmpfs mounts to the container, you can use testcontainers.WithTmpfs
. For example:
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithTmpfs(map[string]string{
"/tmp": "size=100m",
"/run": "size=100m",
}))
WithImageMount¶
- Since v0.37.0
Since Docker v28, it's possible to mount an image to a container, passing the source image name, the relative subpath to mount in that image, and the mount point in the target container.
This option validates that the subpath is a relative path, raising an error otherwise.
newOllamaContainer, err := tcollama.Run(
ctx,
"ollama/ollama:0.5.12",
testcontainers.WithImageMount(targetImage, "root/.ollama/models/", "/root/.ollama/models/"),
)
In the code above, which mounts the directory in which Ollama models are stored, the targetImage
is the name of the image containing the models (an Ollama image where the models are already pulled).
Warning
Using this option fails the creation of the container if the underlying container runtime does not support the image mount
feature.
Build Options¶
WithDockerfile¶
- Since v0.37.0
Testcontainers exposes the testcontainers.WithDockerfile
option to build a container from a Dockerfile.
The functional option receives a testcontainers.FromDockerfile
struct that is applied to the container request before starting the container. As a result, the container is built and started in one go.
df := testcontainers.FromDockerfile{
Context: ".",
Dockerfile: "Dockerfile",
Repo: "testcontainers",
Tag: "latest",
BuildArgs: map[string]*string{"ARG1": nil, "ARG2": nil},
}
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3", testcontainers.WithDockerfile(df))
Logging Options¶
WithLogConsumers¶
- Since v0.28.0
If you need to consume the logs of the container, you can use testcontainers.WithLogConsumers
with a valid log consumer. An example of a log consumer is the following:
type TestLogConsumer struct {
Msgs []string
}
func (g *TestLogConsumer) Accept(l Log) {
g.Msgs = append(g.Msgs, string(l.Content))
}
WithLogConsumerConfig¶
- Not available until the next release main
If you need to set the log consumer config for the container, you can use testcontainers.WithLogConsumerConfig
. This option completely replaces the existing log consumer config, including the log consumers and the log production options.
WithLogger¶
- Since v0.29.0
If you need to either pass logger to a container, you can use testcontainers.WithLogger
.
Info
Consider calling this before other "With" functions as these may generate logs.
In this example we also use the testcontainers-go log.TestLogger
, which writes to the passed in testing.TB
using Logf
.
The result is that we capture all logging from the container into the test context meaning its
hidden behind go test -v
and is associated with the relevant test, providing the user with
useful context instead of appearing out of band.
func TestHandler(t *testing.T) {
logger := log.TestLogger(t)
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3", testcontainers.WithLogger(logger))
CleanupContainer(t, ctr)
require.NoError(t, err)
// Do something with container.
}
Please read the Following Container Logs documentation for more information about creating log consumers.
Image Options¶
WithAlwaysPull¶
- Not available until the next release main
If you need to pull the image before starting the container, you can use testcontainers.WithAlwaysPull()
.
WithImageSubstitutors¶
- Since v0.26.0
In more locked down / secured environments, it can be problematic to pull images from Docker Hub and run them without additional precautions.
An image name substitutor converts a Docker image name, as may be specified in code, to an alternative name. This is intended to provide a way to override image names, for example to enforce pulling of images from a private registry.
Testcontainers for Go exposes an interface to perform this operation: ImageSubstitutor
, and a No-operation implementation to be used as reference for custom implementations:
// ImageSubstitutor represents a way to substitute container image names
type ImageSubstitutor interface {
// Description returns the name of the type and a short description of how it modifies the image.
// Useful to be printed in logs
Description() string
Substitute(image string) (string, error)
}
type NoopImageSubstitutor struct{}
// Description returns a description of what is expected from this Substitutor,
// which is used in logs.
func (s NoopImageSubstitutor) Description() string {
return "NoopImageSubstitutor (noop)"
}
// Substitute returns the original image, without any change
func (s NoopImageSubstitutor) Substitute(image string) (string, error) {
return image, nil
}
Using the WithImageSubstitutors
options, you could define your own substitutions to the container images. E.g. adding a prefix to the images so that they can be pulled from a Docker registry other than Docker Hub. This is the usual mechanism for using Docker image proxies, caches, etc.
WithImagePlatform¶
- Not available until the next release main
If you need to set the platform for a container, you can use testcontainers.WithImagePlatform(platform string)
.
Networking Options¶
WithNetwork¶
- Since v0.27.0
By default, the container is started in the default Docker network. If you want to use an already existing Docker network you created in your code, you can use the network.WithNetwork(aliases []string, nw *testcontainers.DockerNetwork)
option, which receives an alias as parameter and your network, attaching the container to it, and setting the network alias for that network.
In the case you need to retrieve the network name, you can simply read it from the struct's Name
field. E.g. nw.Name
.
Warning
This option is not checking whether the network exists or not. If you use a network that doesn't exist, the container will start in the default Docker network, as in the default behavior.
WithNetworkByName¶
- Not available until the next release main
If you want to attach your containers to an already existing Docker network by its name, you can use the network.WithNetworkName(aliases []string, networkName string)
option, which receives an alias as parameter and the network name, attaching the container to it, and setting the network alias for that network.
Warning
In case the network name is bridge
, no aliases are set. This is because network-scoped alias is supported only for containers in user defined networks.
WithBridgeNetwork¶
- Not available until the next release main
If you want to attach your containers to the bridge
network, you can use the network.WithBridgeNetwork()
option.
Warning
The bridge
network is the default network for Docker. It's not a user defined network, so it doesn't support network-scoped aliases.
WithNewNetwork¶
- Since v0.27.0
If you want to attach your containers to a throw-away network, you can use the network.WithNewNetwork(ctx context.Context, aliases []string, opts ...network.NetworkCustomizer)
option, which receives an alias as parameter, creating the new network with a random name, attaching the container to it, and setting the network alias for that network.
In the case you need to retrieve the network name, you can use the Networks(ctx)
method of the Container
interface, right after it's running, which returns a slice of strings with the names of the networks where the container is attached.
Advanced Options¶
WithHostPortAccess¶
- Since v0.31.0
If you need to access a port that is already running in the host, you can use testcontainers.WithHostPortAccess
for example:
ctr, err = mymodule.Run(ctx, "docker.io/myservice:1.2.3", testcontainers.WithHostPortAccess(8080))
To understand more about this feature, please read the Exposing host ports to the container documentation.
WithConfigModifier¶
- Since v0.20.0
If you need an advanced configuration for the container, modifying the container's configuration, you can use the testcontainers.WithConfigModifier
option, which gives access to the underlying Docker's Config type.
WithHostConfigModifier¶
- Since v0.20.0
If you need an advanced configuration for the container, modifying the container's host configuration, you can use the testcontainers.WithHostConfigModifier
option, which gives access to the underlying Docker's HostConfig type.
WithEndpointSettingsModifier¶
- Since v0.20.0
If you need an advanced configuration for the container, modifying the container's endpoint settings, you can use the testcontainers.WithEndpointSettingsModifier
option, which gives access to the underlying Docker's EndpointSettings type.
CustomizeRequest¶
- Since v0.20.0
This option will merge the customized request into the module's own ContainerRequest
.
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
/* Other module options */
testcontainers.CustomizeRequest(testcontainers.GenericContainerRequest{
ContainerRequest: testcontainers.ContainerRequest{
Cmd: []string{"-c", "log_statement=all"},
},
}),
)
The above example is updating the predefined command of the image, appending them to the module's command.
Info
This can't be used to replace the command, only to append options.
WithName¶
- Not available until the next release main
If you need to set the name of the container, you can use the testcontainers.WithName
option.
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithName("my-container-name"),
)
Warning
This option is not checking whether the container name is already in use. If you use a name that is already in use, an error is returned. At the same time, we discourage using this option as it might lead to unexpected behavior, but we understand that in some cases it might be useful.
WithNoStart¶
- Not available until the next release main
If you need to prevent the container from being started after creation, you can use the testcontainers.WithNoStart
option.
Experimental Options¶
WithReuseByName¶
- Since v0.37.0
This option marks a container to be reused if it exists or create a new one if it doesn't. With the current implementation, the container name must be provided to identify the container to be reused.
ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
testcontainers.WithReuseByName("my-container-name"),
)
Warning
Reusing a container is experimental and the API is subject to change for a more robust implementation that is not based on container names.
GenericContainer¶
Warning
GenericContainer
is the old way to create a container, and we recommend using Run
instead,
as it could be deprecated in the future.
testcontainers.GenericContainer
defines the container that should be run, similar to the docker run
command.
The following test creates an NGINX container on both the bridge
(docker default
network) and the foo
network and validates that it returns 200 for the status code.
It also demonstrates how to use CleanupContainer
ensures that nginx container
is removed when the test ends even if the underlying GenericContainer
errored
as well as the CleanupNetwork
which does the same for networks.
The alternatives for these outside of tests as a defer
are TerminateContainer
and Network.Remove
which can be seen in the examples.
package main
import (
"context"
"fmt"
"net/http"
"testing"
"github.com/testcontainers/testcontainers-go"
"github.com/testcontainers/testcontainers-go/wait"
)
type nginxContainer struct {
testcontainers.Container
URI string
}
func setupNginx(ctx context.Context, networkName string) (*nginxContainer, error) {
req := testcontainers.ContainerRequest{
Image: "nginx",
ExposedPorts: []string{"80/tcp"},
Networks: []string{"bridge", networkName},
WaitingFor: wait.ForHTTP("/"),
}
container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
ContainerRequest: req,
Started: true,
})
var nginxC *nginxContainer
if container != nil {
nginxC = &nginxContainer{Container: container}
}
if err != nil {
return nginxC, err
}
ip, err := container.Host(ctx)
if err != nil {
return nginxC, err
}
mappedPort, err := container.MappedPort(ctx, "80")
if err != nil {
return nginxC, err
}
nginxC.URI = fmt.Sprintf("http://%s:%s", ip, mappedPort.Port())
return nginxC, nil
}
func TestIntegrationNginxLatestReturn(t *testing.T) {
if testing.Short() {
t.Skip("skipping integration test")
}
ctx := context.Background()
nw, err := network.New(ctx)
require.NoError(t, err)
testcontainers.CleanupNetwork(t, nw)
nginxC, err := setupNginx(ctx, nw.Name)
testcontainers.CleanupContainer(t, nginxC)
require.NoError(t, err)
resp, err := http.Get(nginxC.URI)
require.Equal(t, http.StatusOK, resp.StatusCode)
}
Lifecycle hooks¶
Testcontainers for Go allows you to define your own lifecycle hooks for better control over your containers. You just need to define functions that return an error and receive the Go context as first argument, and a ContainerRequest
for the Creating
hook, and a Container
for the rest of them as second argument.
You'll be able to pass multiple lifecycle hooks at the ContainerRequest
as an array of testcontainers.ContainerLifecycleHooks
. The testcontainers.ContainerLifecycleHooks
struct defines the following lifecycle hooks, each of them backed by an array of functions representing the hooks:
PreBuilds
- hooks that are executed before the image is built. This hook is only available when creating a container from a DockerfilePostBuilds
- hooks that are executed after the image is built. This hook is only available when creating a container from a DockerfilePreCreates
- hooks that are executed before the container is createdPostCreates
- hooks that are executed after the container is createdPreStarts
- hooks that are executed before the container is startedPostStarts
- hooks that are executed after the container is startedPostReadies
- hooks that are executed after the container is readyPreStops
- hooks that are executed before the container is stoppedPostStops
- hooks that are executed after the container is stoppedPreTerminates
- hooks that are executed before the container is terminatedPostTerminates
- hooks that are executed after the container is terminated
Testcontainers for Go defines some default lifecycle hooks that are always executed in a specific order with respect to the user-defined hooks. The order of execution is the following:
- default
pre
hooks. - user-defined
pre
hooks. - user-defined
post
hooks. - default
post
hooks.
Inside each group, the hooks will be executed in the order they were defined.
Info
The default hooks are for logging (applied to all hooks), customising the Docker config (applied to the pre-create hook), copying files in to the container (applied to the post-create hook), adding log consumers (applied to the post-start and pre-terminate hooks), and running the wait strategies as a readiness check (applied to the post-start hook).
It's important to notice that the Readiness
of a container is defined by the wait strategies defined for the container. This hook will be executed right after the PostStarts
hook. If you want to add your own readiness checks, you can do it by adding a PostReadies
hook to the container request, which will execute your own readiness check after the default ones. That said, the PostStarts
hooks don't warrant that the container is ready, so you should not rely on that.
In the following example, we are going to create a container using all the lifecycle hooks, all of them printing a message when any of the lifecycle hooks is called:
req := ContainerRequest{
Image: nginxAlpineImage,
LifecycleHooks: []ContainerLifecycleHooks{
{
PreCreates: []ContainerRequestHook{
func(_ context.Context, _ ContainerRequest) error {
prints = append(prints, "pre-create hook 1")
return nil
},
func(_ context.Context, _ ContainerRequest) error {
prints = append(prints, "pre-create hook 2")
return nil
},
},
PostCreates: []ContainerHook{
func(_ context.Context, _ Container) error {
prints = append(prints, "post-create hook 1")
return nil
},
func(_ context.Context, _ Container) error {
prints = append(prints, "post-create hook 2")
return nil
},
},
PreStarts: []ContainerHook{
func(_ context.Context, _ Container) error {
prints = append(prints, "pre-start hook 1")
return nil
},
func(_ context.Context, _ Container) error {
prints = append(prints, "pre-start hook 2")
return nil
},
},
PostStarts: []ContainerHook{
func(_ context.Context, _ Container) error {
prints = append(prints, "post-start hook 1")
return nil
},
func(_ context.Context, _ Container) error {
prints = append(prints, "post-start hook 2")
return nil
},
},
PostReadies: []ContainerHook{
func(_ context.Context, _ Container) error {
prints = append(prints, "post-ready hook 1")
return nil
},
func(_ context.Context, _ Container) error {
prints = append(prints, "post-ready hook 2")
return nil
},
},
PreStops: []ContainerHook{
func(_ context.Context, _ Container) error {
prints = append(prints, "pre-stop hook 1")
return nil
},
func(_ context.Context, _ Container) error {
prints = append(prints, "pre-stop hook 2")
return nil
},
},
PostStops: []ContainerHook{
func(_ context.Context, _ Container) error {
prints = append(prints, "post-stop hook 1")
return nil
},
func(_ context.Context, _ Container) error {
prints = append(prints, "post-stop hook 2")
return nil
},
},
PreTerminates: []ContainerHook{
func(_ context.Context, _ Container) error {
prints = append(prints, "pre-terminate hook 1")
return nil
},
func(_ context.Context, _ Container) error {
prints = append(prints, "pre-terminate hook 2")
return nil
},
},
PostTerminates: []ContainerHook{
func(_ context.Context, _ Container) error {
prints = append(prints, "post-terminate hook 1")
return nil
},
func(_ context.Context, _ Container) error {
prints = append(prints, "post-terminate hook 2")
return nil
},
},
},
},
}
Default Logging Hook¶
Testcontainers for Go comes with a default logging hook that will print a log message for each container lifecycle event, using the default logger. You can add your own logger by passing the testcontainers.DefaultLoggingHook
option to the ContainerRequest
, passing a reference to your preferred logger:
dl := inMemoryLogger{}
req := ContainerRequest{
Image: nginxAlpineImage,
LifecycleHooks: []ContainerLifecycleHooks{
DefaultLoggingHook(&dl),
},
}
type inMemoryLogger struct {
data []string
}
func (l *inMemoryLogger) Printf(format string, args ...any) {
l.data = append(l.data, fmt.Sprintf(format, args...))
}
Advanced Settings¶
The aforementioned GenericContainer
function and the ContainerRequest
struct represent a straightforward manner to configure the containers, but you could need to create your containers with more advance settings regarding the config, host config and endpoint settings Docker types. For those more advance settings, Testcontainers for Go offers a way to fully customize the container request and those internal Docker types. These customisations, called modifiers, will be applied just before the internal call to the Docker client to create the container.
req := ContainerRequest{
Image: nginxAlpineImage, // alpine image does expose port 80
ConfigModifier: func(config *container.Config) {
config.Env = []string{"a=b"}
},
Mounts: ContainerMounts{
{
Source: DockerVolumeMountSource{
Name: "appdata",
VolumeOptions: &mount.VolumeOptions{
Labels: GenericLabels(),
},
},
Target: "/data",
},
},
HostConfigModifier: func(hostConfig *container.HostConfig) {
hostConfig.PortBindings = nat.PortMap{
"80/tcp": []nat.PortBinding{
{
HostIP: "1",
HostPort: "2",
},
},
}
},
EndpointSettingsModifier: func(endpointSettings map[string]*network.EndpointSettings) {
endpointSettings["a"] = &network.EndpointSettings{
Aliases: []string{"b"},
Links: []string{"link1", "link2"},
}
},
}
Warning
The only special case where the modifiers are not applied last, is when there are no exposed ports in the container request and the container does not use a network mode from a container (e.g. req.NetworkMode = container.NetworkMode("container:$CONTAINER_ID")
). In that case, Testcontainers for Go will extract the ports from the underlying Docker image and export them.
Reusable container¶
With Reuse
option you can reuse an existing container. Reusing will work only if you pass an
existing container name via 'req.Name' field. If the name is not in a list of existing containers,
the function will create a new generic container. If Reuse
is true and Name
is empty, you will get error.
The following test creates an NGINX container, adds a file into it and then reuses the container again for checking the file:
package main
import (
"context"
"fmt"
"log"
"github.com/testcontainers/testcontainers-go"
"github.com/testcontainers/testcontainers-go/wait"
)
const (
reusableContainerName = "my_test_reusable_container"
)
func main() {
ctx := context.Background()
n1, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
ContainerRequest: testcontainers.ContainerRequest{
Image: "nginx:1.17.6",
ExposedPorts: []string{"80/tcp"},
WaitingFor: wait.ForListeningPort("80/tcp"),
Name: reusableContainerName,
},
Started: true,
})
defer func() {
if err := testcontainers.TerminateContainer(n1); err != nil {
log.Printf("failed to terminate container: %s", err)
}
}()
if err != nil {
log.Print(err)
return
}
copiedFileName := "hello_copy.sh"
err = n1.CopyFileToContainer(ctx, "./testdata/hello.sh", "/"+copiedFileName, 700)
if err != nil {
log.Print(err)
return
}
n2, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
ContainerRequest: testcontainers.ContainerRequest{
Image: "nginx:1.17.6",
ExposedPorts: []string{"80/tcp"},
WaitingFor: wait.ForListeningPort("80/tcp"),
Name: reusableContainerName,
},
Started: true,
Reuse: true,
})
defer func() {
if err := testcontainers.TerminateContainer(n2); err != nil {
log.Printf("failed to terminate container: %s", err)
}
}()
if err != nil {
log.Print(err)
return
}
c, _, err := n2.Exec(ctx, []string{"bash", copiedFileName})
if err != nil {
log.Print(err)
return
}
fmt.Println(c)
}
Parallel running¶
testcontainers.ParallelContainers
- defines the containers that should be run in parallel mode.
The following test creates two NGINX containers in parallel:
package main
import (
"context"
"fmt"
"log"
"github.com/testcontainers/testcontainers-go"
)
func main() {
ctx := context.Background()
requests := testcontainers.ParallelContainerRequest{
{
ContainerRequest: testcontainers.ContainerRequest{
Image: "nginx",
ExposedPorts: []string{
"10080/tcp",
},
},
Started: true,
},
{
ContainerRequest: testcontainers.ContainerRequest{
Image: "nginx",
ExposedPorts: []string{
"10081/tcp",
},
},
Started: true,
},
}
res, err := testcontainers.ParallelContainers(ctx, requests, testcontainers.ParallelContainersOptions{})
for _, c := range res {
c := c
defer func() {
if err := testcontainers.TerminateContainer(c); err != nil {
log.Printf("failed to terminate container: %s", c)
}
}()
}
if err != nil {
e, ok := err.(testcontainers.ParallelContainersError)
if !ok {
log.Printf("unknown error: %v", err)
return
}
for _, pe := range e.Errors {
fmt.Println(pe.Request, pe.Error)
}
return
}
}