Bootstrap API

Signed-off-by: Gianluca Arbezzano <gianarb92@gmail.com>

Author: Gianluca Arbezzano

.gitignore

@@ -0,0 +1,2 @@
+debug.test
+vendor

Gopkg.lock

@@ -0,0 +1,38 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  name = "github.com/docker/docker"
+  version = "1.13.0"
+
+[[constraint]]
+  name = "github.com/docker/go-connections"
+  version = "0.3.0"
+
+[prune]
+  go-tests = true
+  unused-packages = true

Gopkg.toml

@@ -0,0 +1,81 @@
+When I was working on a Zipkin PR I discovered a nice Java library called
+[testcontainers](https://www.testcontainers.org/).
+
+It provides an easy and clean API over the go docker sdk to run, terminate and
+connect to containers in your tests.
+
+I found myself comfortable programmatically writing the containers I need to run
+an integration/smoke tests. So I started porting this library in Go.
+
+
+This is the API I have defined:
+
+```go
+package main
+
+import (
+    "testing",
+    "github.com/gianarb/testcontainer"
+)
+
+func TestNginxLatestReturn(t *testing.T) {
+	ctx := context.Background()
+	nginxC, err := testcontainer.RunContainer(ctx, "nginx", testcontainer.RequestContainer{
+		ExportedPort: []string{
+			"80/tpc",
+		},
+	})
+	if err != nil {
+		t.Error(err)
+	}
+	defer nginxC.Terminate(ctx)
+	ip, err := nginxC.GetIPAddress(ctx)
+	if err != nil {
+		t.Error(err)
+	}
+	resp, err := http.Get(fmt.Sprintf("http://%s", ip))
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	}
+}
+```
+This is a simple example, you can create one container in my case using the
+`nginx` image. You can get its IP `ip, err := nginxC.GetIPAddress(ctx)` and you
+can use it to make a GET: `resp, err := http.Get(fmt.Sprintf("http://%s", ip))`
+
+To clean your environment you can defer the container termination `defer nginxC.Terminate(ctx)`.
+
+You can build more complex flow using envvar to configure the containers. Let's
+suppose you are testing an application that requites redis:
+
+```go
+ctx := context.Background()
+redisC, err := testcontainer.RunContainer(ctx, "redis", testcontainer.RequestContainer{
+    ExportedPort: []string{
+        "6379/tpc",
+    },
+})
+if err != nil {
+    t.Error(err)
+}
+defer redisC.Terminate(ctx)
+redisIP, err := redisC.GetIPAddress(ctx)
+if err != nil {
+    t.Error(err)
+}
+
+appC, err := testcontainer.RunContainer(ctx, "your/app", testcontainer.RequestContainer{
+    ExportedPort: []string{
+        "8081/tpc",
+    },
+    Env: map[string]string{
+        "REDIS_HOST": fmt.Sprintf("http://%s:6379", redisIP),
+    },
+})
+if err != nil {
+    t.Error(err)
+}
+defer appC.Terminate(ctx)
+
+// your assertions
+```

README.md

@@ -0,0 +1,102 @@
+package testcontainer
+
+import (
+	"context"
+	"strings"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/client"
+	"github.com/docker/go-connections/nat"
+)
+
+// RequestContainer is the input object used to get a running container.
+type RequestContainer struct {
+	Env          map[string]string
+	ExportedPort []string
+	Cmd          string
+}
+
+// Container is the struct used to represent a single container.
+type Container struct {
+	// Container ID from Docker
+	ID string
+	// Cache to retrieve container infromation without re-fetching them from dockerd
+	raw *types.ContainerJSON
+}
+
+// Terminate is used to kill the container. It is usally triggered by as defer function.
+func (c *Container) Terminate(ctx context.Context) error {
+	var err error
+	cli, err := client.NewEnvClient()
+	if err != nil {
+		return err
+	}
+	return cli.ContainerRemove(ctx, c.ID, types.ContainerRemoveOptions{
+		Force: true,
+	})
+}
+
+func inspectContainer(ctx context.Context, c *Container) (*types.ContainerJSON, error) {
+	if c.raw != nil {
+		return c.raw, nil
+	}
+	cli, err := client.NewEnvClient()
+	if err != nil {
+		return nil, err
+	}
+	inspect, err := cli.ContainerInspect(ctx, c.ID)
+	if err != nil {
+		return nil, err
+	}
+	c.raw = &inspect
+	return c.raw, nil
+}
+
+// GetIPAddress returns the ip address for the running container.
+func (c *Container) GetIPAddress(ctx context.Context) (string, error) {
+	inspect, err := inspectContainer(ctx, c)
+	if err != nil {
+		return "", err
+	}
+	return inspect.NetworkSettings.IPAddress, nil
+}
+
+// RunContainer takes a RequestContainer as input and it runs a container via the docker sdk
+func RunContainer(ctx context.Context, containerImage string, input RequestContainer) (*Container, error) {
+	cli, err := client.NewEnvClient()
+	if err != nil {
+		return nil, err
+	}
+
+	exposedPorts := nat.PortSet{}
+	for _, p := range input.ExportedPort {
+		exposedPorts[nat.Port(p)] = struct{}{}
+	}
+
+	env := []string{}
+	for envKey, envVar := range input.Env {
+		env = append(env, envKey+"="+envVar)
+	}
+
+	dockerInput := &container.Config{
+		Image:        containerImage,
+		Env:          env,
+		ExposedPorts: exposedPorts,
+	}
+
+	if input.Cmd != "" {
+		dockerInput.Cmd = strings.Split(input.Cmd, " ")
+	}
+
+	resp, err := cli.ContainerCreate(ctx, dockerInput, nil, nil, "")
+	if err != nil {
+		return nil, err
+	}
+	if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
+		return nil, err
+	}
+	return &Container{
+		ID: resp.ID,
+	}, nil
+}

docker.go

@@ -0,0 +1,32 @@
+package testcontainer
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"testing"
+)
+
+func TestContainerCreation(t *testing.T) {
+	ctx := context.Background()
+	nginxC, err := RunContainer(ctx, "nginx", RequestContainer{
+		ExportedPort: []string{
+			"80/tpc",
+		},
+	})
+	if err != nil {
+		t.Error(err)
+	}
+	defer nginxC.Terminate(ctx)
+	ip, err := nginxC.GetIPAddress(ctx)
+	if err != nil {
+		t.Error(err)
+	}
+	resp, err := http.Get(fmt.Sprintf("http://%s", ip))
+	if err != nil {
+		t.Error(err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected status code %d. Got %d.", http.StatusOK, resp.StatusCode)
+	}
+}