mirrors/vault
1
0
Fork 0
mirror of https://github.com/hashicorp/vault.git synced 2026-05-05 20:36:26 +02:00
Code Issues Projects Releases Wiki Activity

Clean up HABackend tests (#5617)

Browse Source
This commit is contained in:
Calvin Leung Huang 2018-11-01 10:31:09 -07:00 committed by GitHub
parent 934ec9305b
commit 6d6fbf2f57
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 92 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
physical/consul/consul_test.go
View File

@ -558,22 +558,24 @@ func TestConsulHABackend(t *testing.T) {
}()
logger := logging.NewVaultLogger(log.Debug)
b, err := NewConsulBackend(map[string]string{
config := 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)
if !ok {
t.Fatalf("consul does not implement HABackend")
b2, err := NewConsulBackend(config, logger)
if err != nil {
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 {

17
physical/dynamodb/dynamodb_test.go
View File

@ -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)
if !ok {
t.Fatalf("dynamodb does not implement HABackend")
b2, err := NewDynamoDBBackend(config, logger)
if err != nil {
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

19
physical/etcd/etcd3_test.go
View File

@ -18,21 +18,22 @@ func TestEtcd3Backend(t *testing.T) {
}
logger := logging.NewVaultLogger(log.Debug)
b, err := NewEtcdBackend(map[string]string{
config := 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)
ha, ok := b.(physical.HABackend)
if !ok {
t.Fatalf("etcd3 does not implement HABackend")
}
physical.ExerciseHABackend(t, ha, ha)
physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
}

19
physical/etcd/etcd_test.go
View File

@ -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)
b, err := NewEtcdBackend(map[string]string{
config := 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)
ha, ok := b.(physical.HABackend)
if !ok {
t.Fatalf("etcd does not implement HABackend")
}
physical.ExerciseHABackend(t, ha, ha)
physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
}

31
physical/foundationdb/foundationdb_test.go
View File

@ -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)
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)
physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
}
func prepareFoundationDBTestDirectory(t *testing.T, topDir string) (func(), string) {

23
physical/gcs/gcs_ha_test.go
View File

@ -32,25 +32,28 @@ func TestHABackend(t *testing.T) {
testCleanup(t, client, bucket)
defer testCleanup(t, client, bucket)
b := client.Bucket(bucket)
if err := b.Create(context.Background(), projectID, nil); err != nil {
bh := client.Bucket(bucket)
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)
if !ok {
t.Fatalf("does not implement")
b2, err := NewBackend(config, logger)
if err != nil {
t.Fatal(err)
}
physical.ExerciseBackend(t, backend)
physical.ExerciseBackend_ListPrefix(t, backend)
physical.ExerciseHABackend(t, ha, ha)
physical.ExerciseBackend(t, b)
physical.ExerciseBackend_ListPrefix(t, b)
physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
}

2
physical/inmem/inmem_ha_test.go
View File

@ -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))
}

15
physical/mysql/mysql_test.go
View File

@ -78,16 +78,16 @@ func TestMySQLHABackend(t *testing.T) {
// Run vault tests
logger := logging.NewVaultLogger(log.Debug)
b, err := NewMySQLBackend(map[string]string{
config := 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)
if !ok {
t.Fatalf("MySQL does not implement HABackend")
b2, err := NewMySQLBackend(config, logger)
if err != nil {
t.Fatalf("Failed to create new backend: %v", err)
}
physical.ExerciseHABackend(t, ha, ha)
physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
}

15
physical/spanner/spanner_ha_test.go
View File

@ -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)
if !ok {
t.Fatalf("does not implement")
b2, err := NewBackend(config, logger)
if err != nil {
t.Fatal(err)
}
physical.ExerciseHABackend(t, ha, ha)
physical.ExerciseHABackend(t, b.(physical.HABackend), b2.(physical.HABackend))
}

6
physical/testing.go
View File

@ -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

16
physical/zookeeper/zookeeper_test.go
View File

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