Popularity
8.2
Growing
Activity
9.6
Growing
1,710
18
238

Description

Testcontainers-Go is a Go package that makes it simple to create and clean up container-based dependencies for automated integration/smoke tests. The clean, easy-to-use API enables developers to programmatically define containers that should be run as part of a test and clean up those resources when the test is done.

Programming language: Go
License: MIT License
Tags: Testing     Docker     Containers     Go     Golang     Integration Testing    

Testcontainers-go alternatives and similar packages

Based on the "Testing" category.
Alternatively, view testcontainers-go alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of Testcontainers-go or a related project?

Add another 'Testing' Package

README

Main pipeline Go Report Card GoDoc Reference

Testcontainers-Go is a Go package that makes it simple to create and clean up container-based dependencies for automated integration/smoke tests. The clean, easy-to-use API enables developers to programmatically define containers that should be run as part of a test and clean up those resources when the test is done.

Here's an example of a test that spins up an NGINX container validates that it returns 200 for the status code:

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) (*nginxContainer, error) {
    req := testcontainers.ContainerRequest{
        Image:        "nginx",
        ExposedPorts: []string{"80/tcp"},
        WaitingFor:   wait.ForHTTP("/"),
    }
    container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: req,
        Started:          true,
    })
    if err != nil {
        return nil, err
    }

    ip, err := container.Host(ctx)
    if err != nil {
        return nil, err
    }

    mappedPort, err := container.MappedPort(ctx, "80")
    if err != nil {
        return nil, err
    }

    uri := fmt.Sprintf("http://%s:%s", ip, mappedPort.Port())

    return &nginxContainer{Container: container, URI: uri}, nil
}

func TestIntegrationNginxLatestReturn(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping integration test")
    }

    ctx := context.Background()

    nginxC, err := setupNginx(ctx)
    if err != nil {
        t.Fatal(err)
    }

    // Clean up the container after the test is complete
    defer nginxC.Terminate(ctx)

    resp, err := http.Get(nginxC.URI)
    if resp.StatusCode != http.StatusOK {
        t.Fatalf("Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
    }
}

Cleaning up your environment after test completion should be accomplished by deferring the container termination, e.g defer nginxC.Terminate(ctx). Reaper (Ryuk) is also enabled by default to help clean up.

Documentation

More information about TestContainers-Go can be found in [./docs](./docs), which is rendered at golang.testcontainers.org.