Merge multiple functions for creating consul containers into one.

builtin/credential/radius/backend_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/hashicorp/vault/helper/testhelpers/docker"
 	logicaltest "github.com/hashicorp/vault/helper/testhelpers/logical"
 	"github.com/hashicorp/vault/sdk/logical"
 	"github.com/ory/dockertest"
@@ -48,10 +49,7 @@ func prepareRadiusTestContainer(t *testing.T) (func(), string, int) {
 	}
 
 	cleanup := func() {
-		err := pool.Purge(resource)
-		if err != nil {
-			t.Fatalf("Failed to cleanup local container: %s", err)
-		}
+		docker.CleanupResource(t, pool, resource)
 	}
 
 	port, _ := strconv.Atoi(resource.GetPort("1812/udp"))

builtin/logical/cassandra/backend_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/gocql/gocql"
+	"github.com/hashicorp/vault/helper/testhelpers/docker"
 	logicaltest "github.com/hashicorp/vault/helper/testhelpers/logical"
 	"github.com/hashicorp/vault/sdk/logical"
 	"github.com/mitchellh/mapstructure"
@@ -45,10 +46,7 @@ func prepareCassandraTestContainer(t *testing.T) (func(), string, int) {
 	}
 
 	cleanup := func() {
-		err := pool.Purge(resource)
-		if err != nil {
-			t.Fatalf("Failed to cleanup local container: %s", err)
-		}
+		docker.CleanupResource(t, pool, resource)
 	}
 
 	port, _ := strconv.Atoi(resource.GetPort("9042/tcp"))

builtin/logical/consul/backend_test.go

@@ -5,114 +5,17 @@ import (
 	"encoding/base64"
 	"fmt"
 	"log"
-	"os"
 	"reflect"
-	"strings"
 	"testing"
 	"time"
 
 	consulapi "github.com/hashicorp/consul/api"
+	"github.com/hashicorp/vault/helper/testhelpers/consul"
 	logicaltest "github.com/hashicorp/vault/helper/testhelpers/logical"
 	"github.com/hashicorp/vault/sdk/logical"
 	"github.com/mitchellh/mapstructure"
-	"github.com/ory/dockertest"
 )
 
-func prepareTestContainer(t *testing.T, version string) (cleanup func(), retAddress string, consulToken string) {
-	consulToken = os.Getenv("CONSUL_HTTP_TOKEN")
-	retAddress = os.Getenv("CONSUL_HTTP_ADDR")
-	if retAddress != "" {
-		return func() {}, retAddress, consulToken
-	}
-
-	pool, err := dockertest.NewPool("")
-	if err != nil {
-		t.Fatalf("Failed to connect to docker: %s", err)
-	}
-
-	config := `acl { enabled = true default_policy = "deny" }`
-	if strings.HasPrefix(version, "1.3") {
-		config = `datacenter = "test" acl_default_policy = "deny" acl_datacenter = "test" acl_master_token = "test"`
-	}
-
-	dockerOptions := &dockertest.RunOptions{
-		Repository: "consul",
-		Tag:        version,
-		Cmd:        []string{"agent", "-dev", "-client", "0.0.0.0", "-hcl", config},
-	}
-	resource, err := pool.RunWithOptions(dockerOptions)
-	if err != nil {
-		t.Fatalf("Could not start local Consul %s docker container: %s", version, err)
-	}
-
-	cleanup = func() {
-		err := pool.Purge(resource)
-		if err != nil {
-			t.Fatalf("Failed to cleanup local container: %s", err)
-		}
-	}
-
-	retAddress = fmt.Sprintf("localhost:%s", resource.GetPort("8500/tcp"))
-
-	// exponential backoff-retry
-	if err = pool.Retry(func() error {
-		var err error
-		consulConfig := consulapi.DefaultNonPooledConfig()
-		consulConfig.Address = retAddress
-		consul, err := consulapi.NewClient(consulConfig)
-		if err != nil {
-			return err
-		}
-
-		// For version of Consul < 1.4
-		if strings.HasPrefix(version, "1.3") {
-			consulToken = "test"
-			_, err = consul.KV().Put(&consulapi.KVPair{
-				Key:   "setuptest",
-				Value: []byte("setuptest"),
-			}, &consulapi.WriteOptions{
-				Token: consulToken,
-			})
-			if err != nil {
-				return err
-			}
-			return nil
-		}
-
-		// New default behavior
-		aclbootstrap, _, err := consul.ACL().Bootstrap()
-		if err != nil {
-			return err
-		}
-		consulToken = aclbootstrap.SecretID
-		t.Logf("Generated Master token: %s", consulToken)
-		policy := &consulapi.ACLPolicy{
-			Name:        "test",
-			Description: "test",
-			Rules: `node_prefix "" {
-                policy = "write"
-              }
-
-              service_prefix "" {
-                policy = "read"
-              }
-      `,
-		}
-		q := &consulapi.WriteOptions{
-			Token: consulToken,
-		}
-		_, _, err = consul.ACL().PolicyCreate(policy, q)
-		if err != nil {
-			return err
-		}
-		return nil
-	}); err != nil {
-		cleanup()
-		t.Fatalf("Could not connect to docker: %s", err)
-	}
-	return cleanup, retAddress, consulToken
-}
-
 func TestBackend_Config_Access(t *testing.T) {
 	t.Run("config_access", func(t *testing.T) {
 		t.Parallel()
@@ -135,7 +38,7 @@ func testBackendConfigAccess(t *testing.T, version string) {
 		t.Fatal(err)
 	}
 
-	cleanup, connURL, connToken := prepareTestContainer(t, version)
+	cleanup, connURL, connToken := consul.PrepareTestContainer(t, version)
 	defer cleanup()
 
 	connData := map[string]interface{}{
@@ -200,7 +103,7 @@ func testBackendRenewRevoke(t *testing.T, version string) {
 		t.Fatal(err)
 	}
 
-	cleanup, connURL, connToken := prepareTestContainer(t, version)
+	cleanup, connURL, connToken := consul.PrepareTestContainer(t, version)
 	defer cleanup()
 	connData := map[string]interface{}{
 		"address": connURL,
@@ -305,7 +208,7 @@ func testBackendRenewRevoke14(t *testing.T, version string) {
 		t.Fatal(err)
 	}
 
-	cleanup, connURL, connToken := prepareTestContainer(t, version)
+	cleanup, connURL, connToken := consul.PrepareTestContainer(t, version)
 	defer cleanup()
 	connData := map[string]interface{}{
 		"address": connURL,
@@ -414,7 +317,7 @@ func TestBackend_LocalToken(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cleanup, connURL, connToken := prepareTestContainer(t, "1.4.0-rc1")
+	cleanup, connURL, connToken := consul.PrepareTestContainer(t, "1.4.0-rc1")
 	defer cleanup()
 	connData := map[string]interface{}{
 		"address": connURL,
@@ -556,7 +459,7 @@ func testBackendManagement(t *testing.T, version string) {
 		t.Fatal(err)
 	}
 
-	cleanup, connURL, connToken := prepareTestContainer(t, version)
+	cleanup, connURL, connToken := consul.PrepareTestContainer(t, version)
 	defer cleanup()
 	connData := map[string]interface{}{
 		"address": connURL,
@@ -600,7 +503,7 @@ func testBackendBasic(t *testing.T, version string) {
 		t.Fatal(err)
 	}
 
-	cleanup, connURL, connToken := prepareTestContainer(t, version)
+	cleanup, connURL, connToken := consul.PrepareTestContainer(t, version)
 	defer cleanup()
 	connData := map[string]interface{}{
 		"address": connURL,

builtin/logical/database/backend_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/go-test/deep"
 	"github.com/hashicorp/vault/api"
 	"github.com/hashicorp/vault/helper/namespace"
+	"github.com/hashicorp/vault/helper/testhelpers/docker"
 	vaulthttp "github.com/hashicorp/vault/http"
 	"github.com/hashicorp/vault/plugins/database/postgresql"
 	"github.com/hashicorp/vault/sdk/database/dbplugin"
@@ -50,10 +51,7 @@ func preparePostgresTestContainer(t *testing.T, s logical.Storage, b logical.Bac
 	}
 
 	cleanup = func() {
-		err := pool.Purge(resource)
-		if err != nil {
-			t.Fatalf("Failed to cleanup local container: %s", err)
-		}
+		docker.CleanupResource(t, pool, resource)
 	}
 
 	retURL = fmt.Sprintf("postgres://postgres:secret@localhost:%s/database?sslmode=disable", resource.GetPort("5432/tcp"))

builtin/logical/mongodb/backend_test.go

@@ -4,73 +4,20 @@ import (
 	"context"
 	"fmt"
 	"log"
-	"os"
 	"strings"
 	"sync"
 	"testing"
-	"time"
 
 	logicaltest "github.com/hashicorp/vault/helper/testhelpers/logical"
+	"github.com/hashicorp/vault/helper/testhelpers/mongodb"
 	"github.com/hashicorp/vault/sdk/logical"
 	"github.com/mitchellh/mapstructure"
-	dockertest "gopkg.in/ory-am/dockertest.v2"
 )
 
 var (
 	testImagePull sync.Once
 )
 
-func prepareTestContainer(t *testing.T, s logical.Storage, b logical.Backend) (cid dockertest.ContainerID, retURI string) {
-	if os.Getenv("MONGODB_URI") != "" {
-		return "", os.Getenv("MONGODB_URI")
-	}
-
-	// Without this the checks for whether the container has started seem to
-	// never actually pass. There's really no reason to expose the test
-	// containers, so don't.
-	dockertest.BindDockerToLocalhost = "yep"
-
-	testImagePull.Do(func() {
-		dockertest.Pull(dockertest.MongoDBImageName)
-	})
-
-	cid, connErr := dockertest.ConnectToMongoDB(60, 500*time.Millisecond, func(connURI string) bool {
-		connURI = "mongodb://" + connURI
-		// This will cause a validation to run
-		resp, err := b.HandleRequest(context.Background(), &logical.Request{
-			Storage:   s,
-			Operation: logical.UpdateOperation,
-			Path:      "config/connection",
-			Data: map[string]interface{}{
-				"uri": connURI,
-			},
-		})
-		if err != nil || (resp != nil && resp.IsError()) {
-			// It's likely not up and running yet, so return false and try again
-			return false
-		}
-		if resp == nil {
-			t.Fatal("expected warning")
-		}
-
-		retURI = connURI
-		return true
-	})
-
-	if connErr != nil {
-		t.Fatalf("could not connect to database: %v", connErr)
-	}
-
-	return
-}
-
-func cleanupTestContainer(t *testing.T, cid dockertest.ContainerID) {
-	err := cid.KillRemove()
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
 func TestBackend_config_connection(t *testing.T) {
 	var resp *logical.Response
 	var err error
@@ -112,10 +59,8 @@ func TestBackend_basic(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cid, connURI := prepareTestContainer(t, config.StorageView, b)
-	if cid != "" {
-		defer cleanupTestContainer(t, cid)
-	}
+	cleanup, connURI := mongodb.PrepareTestContainer(t, "latest")
+	defer cleanup()
 	connData := map[string]interface{}{
 		"uri": connURI,
 	}
@@ -138,10 +83,8 @@ func TestBackend_roleCrud(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cid, connURI := prepareTestContainer(t, config.StorageView, b)
-	if cid != "" {
-		defer cleanupTestContainer(t, cid)
-	}
+	cleanup, connURI := mongodb.PrepareTestContainer(t, "latest")
+	defer cleanup()
 	connData := map[string]interface{}{
 		"uri": connURI,
 	}
@@ -166,10 +109,8 @@ func TestBackend_leaseWriteRead(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cid, connURI := prepareTestContainer(t, config.StorageView, b)
-	if cid != "" {
-		defer cleanupTestContainer(t, cid)
-	}
+	cleanup, connURI := mongodb.PrepareTestContainer(t, "latest")
+	defer cleanup()
 	connData := map[string]interface{}{
 		"uri": connURI,
 	}

builtin/logical/mysql/backend_test.go

@@ -9,6 +9,7 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/hashicorp/vault/helper/testhelpers/docker"
 	logicaltest "github.com/hashicorp/vault/helper/testhelpers/logical"
 	"github.com/hashicorp/vault/sdk/logical"
 	"github.com/mitchellh/mapstructure"
@@ -31,10 +32,7 @@ func prepareTestContainer(t *testing.T) (func(), string) {
 	}
 
 	cleanup := func() {
-		err := pool.Purge(resource)
-		if err != nil {
-			t.Fatalf("Failed to cleanup local container: %s", err)
-		}
+		docker.CleanupResource(t, pool, resource)
 	}
 
 	retURL := fmt.Sprintf("root:secret@(localhost:%s)/mysql?parseTime=true", resource.GetPort("3306/tcp"))

builtin/logical/nomad/backend_test.go

@@ -10,6 +10,7 @@ import (
 
 	nomadapi "github.com/hashicorp/nomad/api"
 	"github.com/hashicorp/vault/helper/testhelpers"
+	"github.com/hashicorp/vault/helper/testhelpers/docker"
 	"github.com/hashicorp/vault/sdk/logical"
 	"github.com/mitchellh/mapstructure"
 	"github.com/ory/dockertest"
@@ -41,10 +42,7 @@ func prepareTestContainer(t *testing.T) (cleanup func(), retAddress string, noma
 	}
 
 	cleanup = func() {
-		err := pool.Purge(resource)
-		if err != nil {
-			t.Fatalf("Failed to cleanup local container: %s", err)
-		}
+		docker.CleanupResource(t, pool, resource)
 	}
 
 	retAddress = fmt.Sprintf("http://localhost:%s/", resource.GetPort("4646/tcp"))