Clean up HABackend tests (#5617)

physical/consul/consul_test.go

@@ -558,22 +558,24 @@ func TestConsulHABackend(t *testing.T) {
 	}()
 
 	logger := logging.NewVaultLogger(log.Debug)
-
+	config := map[string]string{
-	b, err := NewConsulBackend(map[string]string{
 		"address":      conf.Address,
 		"path":         randPath,
 		"max_parallel": "-1",
 		"token":        conf.Token,
-	}, logger)
+	}
+
+	b, err := NewConsulBackend(config, logger)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
-	ha, ok := b.(physical.HABackend)
+	b2, err := NewConsulBackend(config, logger)
-	if !ok {
+	if err != nil {
-		t.Fatalf("consul does not implement HABackend")
+		t.Fatalf("err: %s", err)
 	}
-	physical.ExerciseHABackend(t, ha, ha)
+
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
 
 	detect, ok := b.(physical.RedirectDetect)
 	if !ok {

physical/dynamodb/dynamodb_test.go

@@ -147,24 +147,27 @@ func TestDynamoDBHABackend(t *testing.T) {
 	}()
 
 	logger := logging.NewVaultLogger(log.Debug)
-	b, err := NewDynamoDBBackend(map[string]string{
+	config := map[string]string{
 		"access_key":    creds.AccessKeyID,
 		"secret_key":    creds.SecretAccessKey,
 		"session_token": creds.SessionToken,
 		"table":         table,
 		"region":        region,
 		"endpoint":      endpoint,
-	}, logger)
+	}
+
+	b, err := NewDynamoDBBackend(config, logger)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
-	ha, ok := b.(physical.HABackend)
+	b2, err := NewDynamoDBBackend(config, logger)
-	if !ok {
+	if err != nil {
-		t.Fatalf("dynamodb does not implement HABackend")
+		t.Fatalf("err: %s", err)
 	}
-	physical.ExerciseHABackend(t, ha, ha)
+
-	testDynamoDBLockTTL(t, ha)
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
+	testDynamoDBLockTTL(t, b.(physical.HABackend))
 }
 
 // Similar to testHABackend, but using internal implementation details to

physical/etcd/etcd3_test.go

@@ -18,21 +18,22 @@ func TestEtcd3Backend(t *testing.T) {
 	}
 
 	logger := logging.NewVaultLogger(log.Debug)
-
+	config := map[string]string{
-	b, err := NewEtcdBackend(map[string]string{
 		"path":     fmt.Sprintf("/vault-%d", time.Now().Unix()),
 		"etcd_api": "3",
-	}, logger)
+	}
+
+	b, err := NewEtcdBackend(config, logger)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	b2, err := NewEtcdBackend(config, logger)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
 	physical.ExerciseBackend(t, b)
 	physical.ExerciseBackend_ListPrefix(t, b)
-
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
-	ha, ok := b.(physical.HABackend)
-	if !ok {
-		t.Fatalf("etcd3 does not implement HABackend")
-	}
-	physical.ExerciseHABackend(t, ha, ha)
 }

physical/etcd/etcd_test.go

@@ -52,20 +52,21 @@ func TestEtcdBackend(t *testing.T) {
 	// Generate new etcd backend. The etcd address is read from ETCD_ADDR. No
 	// need to provide it explicitly.
 	logger := logging.NewVaultLogger(log.Debug)
-
+	config := map[string]string{
-	b, err := NewEtcdBackend(map[string]string{
 		"path": randPath,
-	}, logger)
+	}
+
+	b, err := NewEtcdBackend(config, logger)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	b2, err := NewEtcdBackend(config, logger)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
 	physical.ExerciseBackend(t, b)
 	physical.ExerciseBackend_ListPrefix(t, b)
-
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
-	ha, ok := b.(physical.HABackend)
-	if !ok {
-		t.Fatalf("etcd does not implement HABackend")
-	}
-	physical.ExerciseHABackend(t, ha, ha)
 }

physical/foundationdb/foundationdb_test.go

@@ -110,39 +110,26 @@ func TestFoundationDBBackend(t *testing.T) {
 
 	// Run vault tests
 	logger := logging.NewVaultLogger(log.Debug)
-	b, err := NewFDBBackend(map[string]string{
+	config := map[string]string{
 		"path":         topDir,
 		"api_version":  "510",
 		"cluster_file": clusterFile,
-	}, logger)
+	}
 
+	b, err := NewFDBBackend(config, logger)
+	if err != nil {
+		t.Fatalf("foundationdb: failed to create new backend: %s", err)
+	}
+
+	b2, err := NewFDBBackend(config, logger)
 	if err != nil {
 		t.Fatalf("foundationdb: failed to create new backend: %s", err)
 	}
 
 	physical.ExerciseBackend(t, b)
 	physical.ExerciseBackend_ListPrefix(t, b)
-
 	physical.ExerciseTransactionalBackend(t, b)
-
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
-	ha1, ok := b.(physical.HABackend)
-	if !ok {
-		t.Fatalf("foundationdb does not implement HABackend")
-	}
-
-	b2, err := NewFDBBackend(map[string]string{
-		"path":         topDir,
-		"api_version":  "510",
-		"cluster_file": clusterFile,
-	}, logger)
-
-	if err != nil {
-		t.Fatalf("foundationdb: failed to create new backend for HA test: %s", err)
-	}
-
-	ha2 := b2.(physical.HABackend)
-
-	physical.ExerciseHABackend(t, ha1, ha2)
 }
 
 func prepareFoundationDBTestDirectory(t *testing.T, topDir string) (func(), string) {

physical/gcs/gcs_ha_test.go

@@ -32,25 +32,28 @@ func TestHABackend(t *testing.T) {
 	testCleanup(t, client, bucket)
 	defer testCleanup(t, client, bucket)
 
-	b := client.Bucket(bucket)
+	bh := client.Bucket(bucket)
-	if err := b.Create(context.Background(), projectID, nil); err != nil {
+	if err := bh.Create(context.Background(), projectID, nil); err != nil {
 		t.Fatal(err)
 	}
 
-	backend, err := NewBackend(map[string]string{
+	logger := logging.NewVaultLogger(log.Trace)
+	config := map[string]string{
 		"bucket":     bucket,
 		"ha_enabled": "true",
-	}, logging.NewVaultLogger(log.Trace))
+	}
+
+	b, err := NewBackend(config, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	ha, ok := backend.(physical.HABackend)
+	b2, err := NewBackend(config, logger)
-	if !ok {
+	if err != nil {
-		t.Fatalf("does not implement")
+		t.Fatal(err)
 	}
 
-	physical.ExerciseBackend(t, backend)
+	physical.ExerciseBackend(t, b)
-	physical.ExerciseBackend_ListPrefix(t, backend)
+	physical.ExerciseBackend_ListPrefix(t, b)
-	physical.ExerciseHABackend(t, ha, ha)
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
 }

physical/inmem/inmem_ha_test.go

@@ -15,5 +15,7 @@ func TestInmemHA(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+
+	// Use the same inmem backend to acquire the same set of locks
 	physical.ExerciseHABackend(t, inm.(physical.HABackend), inm.(physical.HABackend))
 }

physical/mysql/mysql_test.go

@@ -78,16 +78,16 @@ func TestMySQLHABackend(t *testing.T) {
 
 	// Run vault tests
 	logger := logging.NewVaultLogger(log.Debug)
-
+	config := map[string]string{
-	b, err := NewMySQLBackend(map[string]string{
 		"address":    address,
 		"database":   database,
 		"table":      table,
 		"username":   username,
 		"password":   password,
 		"ha_enabled": "true",
-	}, logger)
+	}
 
+	b, err := NewMySQLBackend(config, logger)
 	if err != nil {
 		t.Fatalf("Failed to create new backend: %v", err)
 	}
@@ -100,9 +100,10 @@ func TestMySQLHABackend(t *testing.T) {
 		}
 	}()
 
-	ha, ok := b.(physical.HABackend)
+	b2, err := NewMySQLBackend(config, logger)
-	if !ok {
+	if err != nil {
-		t.Fatalf("MySQL does not implement HABackend")
+		t.Fatalf("Failed to create new backend: %v", err)
 	}
-	physical.ExerciseHABackend(t, ha, ha)
+
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
 }

physical/spanner/spanner_ha_test.go

@@ -38,20 +38,23 @@ func TestHABackend(t *testing.T) {
 	testCleanup(t, client, haTable)
 	defer testCleanup(t, client, haTable)
 
-	backend, err := NewBackend(map[string]string{
+	logger := logging.NewVaultLogger(log.Debug)
+	config := map[string]string{
 		"database":   database,
 		"table":      table,
 		"ha_table":   haTable,
 		"ha_enabled": "true",
-	}, logging.NewVaultLogger(log.Debug))
+	}
+
+	b, err := NewBackend(config, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	ha, ok := backend.(physical.HABackend)
+	b2, err := NewBackend(config, logger)
-	if !ok {
+	if err != nil {
-		t.Fatalf("does not implement")
+		t.Fatal(err)
 	}
 
-	physical.ExerciseHABackend(t, ha, ha)
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
 }

physical/testing.go

@@ -336,7 +336,7 @@ func ExerciseHABackend(t testing.TB, b HABackend, b2 HABackend) {
 		t.Fatalf("stop lock 2: %v", err)
 	}
 	if leaderCh2 != nil {
-		t.Errorf("should not have gotten leaderCh: %v", leaderCh)
+		t.Errorf("should not have gotten leaderCh: %v", leaderCh2)
 	}
 
 	// Release the first lock
@@ -352,7 +352,7 @@ func ExerciseHABackend(t testing.TB, b HABackend, b2 HABackend) {
 	}
 
 	// Check the value
-	held, val, err = lock.Value()
+	held, val, err = lock2.Value()
 	if err != nil {
 		t.Fatalf("value: %v", err)
 	}
@@ -360,7 +360,7 @@ func ExerciseHABackend(t testing.TB, b HABackend, b2 HABackend) {
 		t.Errorf("should still be held")
 	}
 	if val != "baz" {
-		t.Errorf("expected value baz: %v", err)
+		t.Errorf("expected: baz, got: %v", val)
 	}
 
 	// Cleanup

physical/zookeeper/zookeeper_test.go

@@ -85,18 +85,20 @@ func TestZooKeeperHABackend(t *testing.T) {
 	}()
 
 	logger := logging.NewVaultLogger(log.Debug)
-
+	config := map[string]string{
-	b, err := NewZooKeeperBackend(map[string]string{
 		"address": addr + "," + addr,
 		"path":    randPath,
-	}, logger)
+	}
+
+	b, err := NewZooKeeperBackend(config, logger)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
-	ha, ok := b.(physical.HABackend)
+	b2, err := NewZooKeeperBackend(config, logger)
-	if !ok {
+	if err != nil {
-		t.Fatalf("zookeeper does not implement HABackend")
+		t.Fatalf("err: %s", err)
 	}
-	physical.ExerciseHABackend(t, ha, ha)
+
+	physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
 }