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

update gcs backend tests- now strongly consistent (#3231)

Browse Source
This commit is contained in:
Christopher Pauley 2017-08-24 07:11:11 -07:00 committed by Jeff Mitchell
parent c228f880c8
commit 446c25aacc
2 changed files with 2 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
physical/gcs/gcs_test.go
View File

@ -17,11 +17,6 @@ import (
"google.golang.org/api/option"
)
var ConsistencyDelays = physical.Delays{
BeforeList: 5 * time.Second,
BeforeGet: 0 * time.Second,
}
func TestGCSBackend(t *testing.T) {
credentialsFile := os.Getenv("GOOGLE_APPLICATION_CREDENTIALS")
@ -55,7 +50,6 @@ func TestGCSBackend(t *testing.T) {
defer func() {
objects_it := bucket.Objects(context.Background(), nil)
time.Sleep(ConsistencyDelays.BeforeList)
// have to delete all objects before deleting bucket
for {
objAttrs, err := objects_it.Next()
@ -71,8 +65,6 @@ func TestGCSBackend(t *testing.T) {
bucket.Object(objAttrs.Name).Delete(context.Background())
}
// not a list operation, but google lists to make sure the bucket is empty on delete
time.Sleep(ConsistencyDelays.BeforeList)
err := bucket.Delete(context.Background())
if err != nil {
t.Fatalf("error deleting bucket '%s': '%v'", bucketName, err)
@ -90,7 +82,7 @@ func TestGCSBackend(t *testing.T) {
t.Fatalf("error creating google cloud storage backend: '%s'", err)
}
physical.ExerciseEventuallyConsistentBackend(t, b, ConsistencyDelays)
physical.ExerciseEventuallyConsistentBackend_ListPrefix(t, b, ConsistencyDelays)
physical.ExerciseBackend(t, b)
physical.ExerciseBackend_ListPrefix(t, b)
}

272
physical/testing.go
View File

@ -341,278 +341,6 @@ func ExerciseHABackend(t *testing.T, b HABackend, b2 HABackend) {
lock2.Unlock()
}
type Delays struct {
BeforeGet time.Duration
BeforeList time.Duration
}
func ExerciseEventuallyConsistentBackend(t *testing.T, b Backend, d Delays) {
// no delay required: nothing written to bucket
// Should be empty
keys, err := b.List("")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 0 {
t.Fatalf("bad: %v", keys)
}
// Delete should work if it does not exist
err = b.Delete("foo")
if err != nil {
t.Fatalf("err: %v", err)
}
// no delay required: nothing written to bucket
// Get should fail
out, err := b.Get("foo")
if err != nil {
t.Fatalf("err: %v", err)
}
if out != nil {
t.Fatalf("bad: %v", out)
}
// Make an entry
e := &Entry{Key: "foo", Value: []byte("test")}
err = b.Put(e)
if err != nil {
t.Fatalf("err: %v", err)
}
// Get should work
time.Sleep(d.BeforeGet)
out, err = b.Get("foo")
if err != nil {
t.Fatalf("err: %v", err)
}
if !reflect.DeepEqual(out, e) {
t.Fatalf("bad: %v expected: %v", out, e)
}
// List should not be empty
time.Sleep(d.BeforeList)
keys, err = b.List("")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 1 {
t.Fatalf("bad: %v", keys)
}
if keys[0] != "foo" {
t.Fatalf("bad: %v", keys)
}
// Delete should work
err = b.Delete("foo")
if err != nil {
t.Fatalf("err: %v", err)
}
// Should be empty
time.Sleep(d.BeforeList)
keys, err = b.List("")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 0 {
t.Fatalf("bad: %v", keys)
}
// Get should fail
time.Sleep(d.BeforeGet)
out, err = b.Get("foo")
if err != nil {
t.Fatalf("err: %v", err)
}
if out != nil {
t.Fatalf("bad: %v", out)
}
// Multiple Puts should work; GH-189
e = &Entry{Key: "foo", Value: []byte("test")}
err = b.Put(e)
if err != nil {
t.Fatalf("err: %v", err)
}
e = &Entry{Key: "foo", Value: []byte("test")}
err = b.Put(e)
if err != nil {
t.Fatalf("err: %v", err)
}
// Make a nested entry
e = &Entry{Key: "foo/bar", Value: []byte("baz")}
err = b.Put(e)
if err != nil {
t.Fatalf("err: %v", err)
}
time.Sleep(d.BeforeList)
keys, err = b.List("")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 2 {
t.Fatalf("bad: %v", keys)
}
sort.Strings(keys)
if keys[0] != "foo" || keys[1] != "foo/" {
t.Fatalf("bad: %v", keys)
}
// Delete with children should work
err = b.Delete("foo")
if err != nil {
t.Fatalf("err: %v", err)
}
// Get should return the child
time.Sleep(d.BeforeGet)
out, err = b.Get("foo/bar")
if err != nil {
t.Fatalf("err: %v", err)
}
if out == nil {
t.Fatalf("missing child")
}
// Removal of nested secret should not leave artifacts
e = &Entry{Key: "foo/nested1/nested2/nested3", Value: []byte("baz")}
err = b.Put(e)
if err != nil {
t.Fatalf("err: %v", err)
}
err = b.Delete("foo/nested1/nested2/nested3")
if err != nil {
t.Fatalf("failed to remove nested secret: %v", err)
}
time.Sleep(d.BeforeList)
keys, err = b.List("foo/")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 1 {
t.Fatalf("there should be only one key left after deleting nested "+
"secret: %v", keys)
}
if keys[0] != "bar" {
t.Fatalf("bad keys after deleting nested: %v", keys)
}
// Make a second nested entry to test prefix removal
e = &Entry{Key: "foo/zip", Value: []byte("zap")}
err = b.Put(e)
if err != nil {
t.Fatalf("err: %v", err)
}
// Delete should not remove the prefix
err = b.Delete("foo/bar")
if err != nil {
t.Fatalf("err: %v", err)
}
time.Sleep(d.BeforeList)
keys, err = b.List("")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 1 {
t.Fatalf("bad: %v", keys)
}
if keys[0] != "foo/" {
t.Fatalf("bad: %v", keys)
}
// Delete should remove the prefix
err = b.Delete("foo/zip")
if err != nil {
t.Fatalf("err: %v", err)
}
time.Sleep(d.BeforeList)
keys, err = b.List("")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 0 {
t.Fatalf("bad: %v", keys)
}
}
func ExerciseEventuallyConsistentBackend_ListPrefix(t *testing.T, b Backend, d Delays) {
e1 := &Entry{Key: "foo", Value: []byte("test")}
e2 := &Entry{Key: "foo/bar", Value: []byte("test")}
e3 := &Entry{Key: "foo/bar/baz", Value: []byte("test")}
err := b.Put(e1)
if err != nil {
t.Fatalf("err: %v", err)
}
err = b.Put(e2)
if err != nil {
t.Fatalf("err: %v", err)
}
err = b.Put(e3)
if err != nil {
t.Fatalf("err: %v", err)
}
// Scan the root
time.Sleep(d.BeforeList)
keys, err := b.List("")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 2 {
t.Fatalf("bad: %v", keys)
}
sort.Strings(keys)
if keys[0] != "foo" {
t.Fatalf("bad: %v", keys)
}
if keys[1] != "foo/" {
t.Fatalf("bad: %v", keys)
}
// Scan foo/
time.Sleep(d.BeforeList)
keys, err = b.List("foo/")
if err != nil {
t.Fatalf("err: %v", err)
}
if len(keys) != 2 {
t.Fatalf("bad: %v", keys)
}
sort.Strings(keys)
if keys[0] != "bar" {
t.Fatalf("bad: %v", keys)
}
if keys[1] != "bar/" {
t.Fatalf("bad: %v", keys)
}
// Scan foo/bar/
time.Sleep(d.BeforeList)
keys, err = b.List("foo/bar/")
if err != nil {
t.Fatalf("err: %v", err)
}
sort.Strings(keys)
if len(keys) != 1 {
t.Fatalf("bad: %v", keys)
}
if keys[0] != "baz" {
t.Fatalf("bad: %v", keys)
}
}
func ExerciseTransactionalBackend(t *testing.T, b Backend) {
tb, ok := b.(Transactional)
if !ok {