LocalStack

The Testcontainers module for LocalStack is "a fully functional local AWS cloud stack", to develop and test your cloud and serverless apps without actually using the cloud.

Adding this module to your project dependencies

Please run the following command to add the LocalStack module to your Go dependencies:

go get github.com/testcontainers/testcontainers-go/modules/localstack

Usage example

Running LocalStack as a stand-in for multiple AWS services during a test:

Creating a LocalStack container

container, err := localstack.StartContainer(ctx, localstack.NoopOverrideContainerRequest)
require.Nil(t, err)

Environment variables listed in Localstack's README may be used to customize Localstack's configuration. Use the OverrideContainerRequest option when creating the LocalStackContainer to apply configuration settings.

Creating a client using the AWS SDK for Go

Version 1

Test for a LocalStack container, usinv AWS SDK v1

// awsSession returns a new AWS session for the given service. To retrieve the specific AWS service client, use the
// session's client method, e.g. s3manager.NewUploader(session).
func awsSession(ctx context.Context, l *localstack.LocalStackContainer) (*session.Session, error) {
    mappedPort, err := l.MappedPort(ctx, nat.Port("4566/tcp"))
    if err != nil {
        return &session.Session{}, err
    }

    provider, err := testcontainers.NewDockerProvider()
    if err != nil {
        return &session.Session{}, err
    }

    host, err := provider.DaemonHost(ctx)
    if err != nil {
        return &session.Session{}, err
    }

    awsConfig := &aws.Config{
        Region:                        aws.String(region),
        CredentialsChainVerboseErrors: aws.Bool(true),
        Credentials:                   credentials.NewStaticCredentials(accesskey, secretkey, token),
        S3ForcePathStyle:              aws.Bool(true),
        Endpoint:                      aws.String(fmt.Sprintf("http://%s:%d", host, mappedPort.Int())),
    }

    return session.NewSession(awsConfig)
}

For further reference on the SDK v1, please check out the AWS docs here.

Version 2

Test for a LocalStack container, usinv AWS SDK v2

func s3Client(ctx context.Context, l *localstack.LocalStackContainer) (*s3.Client, error) {
    mappedPort, err := l.MappedPort(ctx, nat.Port("4566/tcp"))
    if err != nil {
        return nil, err
    }

    provider, err := testcontainers.NewDockerProvider()
    if err != nil {
        return nil, err
    }

    host, err := provider.DaemonHost(ctx)
    if err != nil {
        return nil, err
    }

    customResolver := aws.EndpointResolverWithOptionsFunc(
        func(service, region string, opts ...interface{}) (aws.Endpoint, error) {
            return aws.Endpoint{
                PartitionID:   "aws",
                URL:           fmt.Sprintf("http://%s:%d", host, mappedPort.Int()),
                SigningRegion: region,
            }, nil
        })

    awsCfg, err := config.LoadDefaultConfig(context.TODO(),
        config.WithRegion(region),
        config.WithEndpointResolverWithOptions(customResolver),
        config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accesskey, secretkey, token)),
    )
    if err != nil {
        return nil, err
    }

    client := s3.NewFromConfig(awsCfg, func(o *s3.Options) {
        o.UsePathStyle = true
    })

    return client, nil
}

For further reference on the SDK v2, please check out the AWS docs here

`HOSTNAME_EXTERNAL` and hostname-sensitive services

Some Localstack APIs, such as SQS, require the container to be aware of the hostname that it is accessible on - for example, for construction of queue URLs in responses.

Testcontainers will inform Localstack of the best hostname automatically, using the HOSTNAME_EXTERNAL environment variable:

when running the Localstack container directly without a custom network defined, it is expected that all calls to the container will be from the test host. As such, the container address will be used (typically localhost or the address where the Docker daemon is running).

Localstack container running without a custom network
```
container, err := StartContainer(
    ctx,
    OverrideContainerRequest(testcontainers.ContainerRequest{
        Image: fmt.Sprintf("localstack/localstack:%s", defaultVersion),
    }),
)
```

when running the Localstack container with a custom network defined, it is expected that all calls to the container will be from other containers on that network. HOSTNAME_EXTERNAL will be set to the last network alias that has been configured for the Localstack container.

Localstack container running with a custom network

ctx := context.Background()

nw, err := testcontainers.GenericNetwork(ctx, testcontainers.GenericNetworkRequest{
    NetworkRequest: testcontainers.NetworkRequest{
        Name: "localstack-network",
    },
})
require.Nil(t, err)
assert.NotNil(t, nw)

container, err := StartContainer(
    ctx,
    OverrideContainerRequest(testcontainers.ContainerRequest{
        Image:          "localstack/localstack:0.13.0",
        Env:            map[string]string{"SERVICES": "s3,sqs"},
        Networks:       []string{"localstack-network"},
        NetworkAliases: map[string][]string{"localstack-network": {"localstack"}},
    }),
)
require.Nil(t, err)
assert.NotNil(t, container)

Other usage scenarios, such as where the Localstack container is used from both the test host and containers on a custom network are not automatically supported. If you have this use case, you should set HOSTNAME_EXTERNAL manually.

Module reference

The LocalStack module exposes one single function to create the LocalStack container, and this function receives two parameters:

func StartContainer(ctx context.Context, overrideReq OverrideContainerRequestOption) (*LocalStackContainer, error)

context.Context
OverrideContainerRequestOption

OverrideContainerRequestOption

The OverrideContainerRequestOption functional option represents a way to override the default LocalStack container request:

Default container request

req := testcontainers.ContainerRequest{
    Image:        fmt.Sprintf("localstack/localstack:%s", defaultVersion),
    Binds:        []string{fmt.Sprintf("%s:/var/run/docker.sock", testcontainersdocker.ExtractDockerHost(ctx))},
    WaitingFor:   wait.ForHTTP("/_localstack/health").WithPort("4566/tcp").WithStartupTimeout(120 * time.Second),
    ExposedPorts: []string{fmt.Sprintf("%d/tcp", defaultPort)},
    Env:          map[string]string{},
}

With simply passing your own instance of an OverrideContainerRequestOption type to the StartContainer function, you'll be able to configure the LocalStack container with your own needs, as this new container request will be merged with the original one.

In the following example you check how it's possible to set certain environment variables that are needed by the tests, the most important of them the AWS services you want to use. Besides, the container runs in a separate Docker network with an alias:

Overriding the default container request

ctx := context.Background()

nw, err := testcontainers.GenericNetwork(ctx, testcontainers.GenericNetworkRequest{
    NetworkRequest: testcontainers.NetworkRequest{
        Name: "localstack-network",
    },
})
require.Nil(t, err)
assert.NotNil(t, nw)

container, err := StartContainer(
    ctx,
    OverrideContainerRequest(testcontainers.ContainerRequest{
        Image:          "localstack/localstack:0.13.0",
        Env:            map[string]string{"SERVICES": "s3,sqs"},
        Networks:       []string{"localstack-network"},
        NetworkAliases: map[string][]string{"localstack-network": {"localstack"}},
    }),
)
require.Nil(t, err)
assert.NotNil(t, container)

If you do not need to override the container request, you can pass nil or the NoopOverrideContainerRequest instance, which is exposed as a helper for this reason.

Skip overriding the default container request

ctx := context.Background()

container, err := StartContainer(
    ctx,
    NoopOverrideContainerRequest,
)
require.Nil(t, err)
assert.NotNil(t, container)

Testing the module

The module includes unit and integration tests that can be run from its source code. To run the tests please execute the following command:

cd modules/localstack
make test

Info

At this moment, the tests for the module include tests for the S3 service, only. They live in two different Go packages of the LocalStack module, v1 and v2, where it'll be easier to add more examples for the rest of services.