all: run Docker dependent tests whenever possible

internal/docstore/mongodocstore/mongo_test.go

@@ -30,6 +30,7 @@ import (
 	"gocloud.dev/internal/docstore"
 	"gocloud.dev/internal/docstore/driver"
 	"gocloud.dev/internal/docstore/drivertest"
+	"gocloud.dev/internal/testing/setup"
 )
 
 const (
@@ -136,16 +137,16 @@ func TestConformance(t *testing.T) {
 }
 
 func newTestClient(t *testing.T) *mongo.Client {
+	if !setup.HasDockerTestEnvironment() {
+		t.Skip("Skipping Mongo tests since the Mongo server is not available")
+	}
 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 	defer cancel()
 	client, err := Dial(ctx, serverURI)
 	if err != nil {
 		t.Fatalf("dialing to %s: %v", serverURI, err)
 	}
 	if err := client.Ping(ctx, nil); err != nil {
-		if err == context.DeadlineExceeded {
-			t.Skip("could not connect to local mongoDB server (connection timed out)")
-		}
 		t.Fatalf("connecting to %s: %v", serverURI, err)
 	}
 	return client

internal/testing/runchecks.sh

@@ -63,7 +63,7 @@ fi
 
 # start_local_deps.sh requires that Docker is installed, via Travis services,
 # which are only supported on Linux.
-# Without the dependencies running, tests that depend on them are skipped.
+# Tests that depend on them should check the Travis environment before running.
 if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
   echo
   echo "Starting local dependencies..."

internal/testing/setup/setup.go

@@ -334,3 +334,11 @@ func NewGCPDialOptions(t *testing.T, recording bool, filename string) (opts []gr
 	}
 	return opts, done
 }
+
+// HasDockerTestEnvironment returns true when either:
+// 1) Not on Travis.
+// 2) On Travis Linux environment, where Docker is available.
+func HasDockerTestEnvironment() bool {
+	s := os.Getenv("TRAVIS_OS_NAME")
+	return s == "" || s == "linux"
+}

pubsub/kafkapubsub/kafka_test.go

@@ -33,6 +33,7 @@ import (
 	"github.com/Shopify/sarama"
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
+	"gocloud.dev/internal/testing/setup"
 	"gocloud.dev/pubsub"
 	"gocloud.dev/pubsub/driver"
 	"gocloud.dev/pubsub/drivertest"
@@ -55,19 +56,19 @@ type harness struct {
 var checkOnce sync.Once
 var kafkaRunning bool
 
-func localKafkaRunning() bool {
+func localKafkaRunning() (err error) {
 	checkOnce.Do(func() {
-		_, err := sarama.NewClient(localBrokerAddrs, MinimalConfig())
-		if err == nil {
-			kafkaRunning = true
-		}
+		_, err = sarama.NewClient(localBrokerAddrs, MinimalConfig())
 	})
-	return kafkaRunning
+	return err
 }
 
 func newHarness(ctx context.Context, t *testing.T) (drivertest.Harness, error) {
-	if !localKafkaRunning() {
-		t.Skip("No local Kafka running, see pubsub/kafkapubsub/localkafka.sh")
+	if !setup.HasDockerTestEnvironment() {
+		t.Skip("Skipping Kafka tests since the Kafka server is not available")
+	}
+	if err := localKafkaRunning(); err != nil {
+		t.Fatalf("No local Kafka running: %v, see pubsub/kafkapubsub/localkafka.sh", err)
 	}
 	return &harness{uniqueID: rand.Int()}, nil
 }
@@ -196,8 +197,11 @@ func (asTest) BeforeSend(as func(interface{}) bool) error {
 
 // TestKafkaKey tests sending/receiving a message with the Kafka message key set.
 func TestKafkaKey(t *testing.T) {
-	if !localKafkaRunning() {
-		t.Skip("No local Kafka running, see pubsub/kafkapubsub/localkafka.sh")
+	if !setup.HasDockerTestEnvironment() {
+		t.Skip("Skipping Kafka tests since the Kafka server is not available")
+	}
+	if err := localKafkaRunning(); err != nil {
+		t.Fatalf("No local Kafka running: %v, see pubsub/kafkapubsub/localkafka.sh", err)
 	}
 	const (
 		keyName  = "kafkakey"

pubsub/rabbitpubsub/rabbit_test.go

@@ -32,6 +32,7 @@ import (
 
 	"github.com/streadway/amqp"
 	"gocloud.dev/gcerrors"
+	"gocloud.dev/internal/testing/setup"
 	"gocloud.dev/pubsub"
 	"gocloud.dev/pubsub/driver"
 	"gocloud.dev/pubsub/drivertest"
@@ -42,13 +43,16 @@ const rabbitURL = "amqp://guest:guest@localhost:5672/"
 var logOnce sync.Once
 
 func mustDialRabbit(t testing.TB) amqpConnection {
-	conn, err := amqp.Dial(rabbitURL)
-	if err != nil {
+	if !setup.HasDockerTestEnvironment() {
 		logOnce.Do(func() {
-			t.Logf("using the fake because the RabbitMQ server is not up (dial error: %v)", err)
+			t.Log("using the fake because the RabbitMQ server is not available")
 		})
 		return newFakeConnection()
 	}
+	conn, err := amqp.Dial(rabbitURL)
+	if err != nil {
+		t.Fatal(err)
+	}
 	logOnce.Do(func() {
 		t.Logf("using the RabbitMQ server at %s", rabbitURL)
 	})

runtimevar/etcdvar/etcdvar_test.go

@@ -24,6 +24,7 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"go.etcd.io/etcd/clientv3"
 	"go.etcd.io/etcd/etcdserver/api/v3rpc/rpctypes"
+	"gocloud.dev/internal/testing/setup"
 	"gocloud.dev/runtimevar"
 	"gocloud.dev/runtimevar/driver"
 	"gocloud.dev/runtimevar/drivertest"
@@ -38,20 +39,25 @@ var (
 )
 
 func init() {
-	etcdClient, etcdError = clientv3.NewFromURL("http://localhost:2379")
-	if etcdError == nil {
-		// Check to see if the local etcd is actually running.
-		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-		defer cancel()
-		_, etcdError = etcdClient.Put(ctx, "unused", "unused")
+	if setup.HasDockerTestEnvironment() {
+		etcdClient, etcdError = clientv3.NewFromURL("http://localhost:2379")
+		if etcdError == nil {
+			// Check to see if the local etcd is actually running.
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+			defer cancel()
+			_, etcdError = etcdClient.Put(ctx, "unused", "unused")
+		}
 	}
 }
 
 type harness struct{}
 
 func newHarness(t *testing.T) (drivertest.Harness, error) {
+	if !setup.HasDockerTestEnvironment() {
+		t.Skip("Skipping etcd tests since the etcd server is not available")
+	}
 	if etcdError != nil {
-		t.Skip("No local etcd server running, see runtimevar/etcdvar/localetcd.sh")
+		t.Fatal("No local etcd server running, see runtimevar/etcdvar/localetcd.sh", etcdError)
 	}
 	return &harness{}, nil
 }

secrets/vault/vault_test.go

@@ -18,10 +18,12 @@ import (
 	"context"
 	"errors"
 	"os"
+	"sync"
 	"testing"
 	"time"
 
 	"github.com/hashicorp/vault/api"
+	"gocloud.dev/internal/testing/setup"
 	"gocloud.dev/secrets"
 	"gocloud.dev/secrets/driver"
 	"gocloud.dev/secrets/drivertest"
@@ -37,6 +39,8 @@ const (
 	testToken  = "faketoken"
 )
 
+var enableTransit sync.Once
+
 type harness struct {
 	client *api.Client
 	close  func()
@@ -49,6 +53,9 @@ func (h *harness) MakeDriver(ctx context.Context) (driver.Keeper, driver.Keeper,
 func (h *harness) Close() {}
 
 func newHarness(ctx context.Context, t *testing.T) (drivertest.Harness, error) {
+	if !setup.HasDockerTestEnvironment() {
+		t.Skip("Skipping Vault tests since the Vault server is not available")
+	}
 	c, err := Dial(ctx, &Config{
 		Token: testToken,
 		APIConfig: api.Config{
@@ -60,9 +67,17 @@ func newHarness(ctx context.Context, t *testing.T) (drivertest.Harness, error) {
 	}
 	c.SetClientTimeout(3 * time.Second)
 	// Enable the Transit Secrets Engine to use Vault as an Encryption as a Service.
-	if _, err := c.Logical().Write("sys/mounts/transit", map[string]interface{}{"type": "transit"}); err != nil {
-		t.Skip(err, "run secrets/vault/localvault.sh to start a dev vault container")
-	}
+	enableTransit.Do(func() {
+		s, err := c.Logical().Read("sys/mounts")
+		if err != nil {
+			t.Fatal(err, "; run secrets/vault/localvault.sh to start a dev vault container")
+		}
+		if _, ok := s.Data["transit/"]; !ok {
+			if _, err := c.Logical().Write("sys/mounts/transit", map[string]interface{}{"type": "transit"}); err != nil {
+				t.Fatal(err, "; run secrets/vault/localvault.sh to start a dev vault container")
+			}
+		}
+	})
 
 	return &harness{
 		client: c,