c349e97168
/cc @armon - This is a reasonably major refactor that I think cleans up a lot of the logic with secrets in responses. The reason for the refactor is that while implementing Renew/Revoke in logical/framework I found the existing API to be really awkward to work with. Primarily, we needed a way to send down internal data for Vault core to store since not all the data you need to revoke a key is always sent down to the user (for example the user than AWS key belongs to). At first, I was doing this manually in logical/framework with req.Storage, but this is going to be such a common event that I think its something core should assist with. Additionally, I think the added context for secrets will be useful in the future when we have a Vault API for returning orphaned out keys: we can also return the internal data that might help an operator. So this leads me to this refactor. I've removed most of the fields in `logical.Response` and replaced it with a single `*Secret` pointer. If this is non-nil, then the response represents a secret. The Secret struct encapsulates all the lease info and such. It also has some fields on it that are only populated at _request_ time for Revoke/Renew operations. There is precedent for this sort of behavior in the Go stdlib where http.Request/http.Response have fields that differ based on client/server. I copied this style. All core unit tests pass. The APIs fail for obvious reasons but I'll fix that up in the next commit.
141 lines
2.9 KiB
Go
141 lines
2.9 KiB
Go
package vault
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/hashicorp/vault/logical"
|
|
)
|
|
|
|
func TestPassthroughBackend_RootPaths(t *testing.T) {
|
|
b := testPassthroughBackend()
|
|
root := b.RootPaths()
|
|
if len(root) != 0 {
|
|
t.Fatalf("unexpected: %v", root)
|
|
}
|
|
}
|
|
|
|
func TestPassthroughBackend_Write(t *testing.T) {
|
|
b := testPassthroughBackend()
|
|
req := logical.TestRequest(t, logical.WriteOperation, "foo")
|
|
req.Data["raw"] = "test"
|
|
|
|
resp, err := b.HandleRequest(req)
|
|
if err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
if resp != nil {
|
|
t.Fatalf("bad: %v", resp)
|
|
}
|
|
|
|
out, err := req.Storage.Get("foo")
|
|
if err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
if out == nil {
|
|
t.Fatalf("failed to write to view")
|
|
}
|
|
}
|
|
|
|
func TestPassthroughBackend_Read(t *testing.T) {
|
|
b := testPassthroughBackend()
|
|
req := logical.TestRequest(t, logical.WriteOperation, "foo")
|
|
req.Data["raw"] = "test"
|
|
req.Data["lease"] = "1h"
|
|
storage := req.Storage
|
|
|
|
if _, err := b.HandleRequest(req); err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
|
|
req = logical.TestRequest(t, logical.ReadOperation, "foo")
|
|
req.Storage = storage
|
|
|
|
resp, err := b.HandleRequest(req)
|
|
if err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
|
|
expected := &logical.Response{
|
|
Secret: &logical.Secret{
|
|
Renewable: false,
|
|
Lease: time.Hour,
|
|
},
|
|
Data: map[string]interface{}{
|
|
"raw": "test",
|
|
"lease": "1h",
|
|
},
|
|
}
|
|
|
|
resp.Secret.InternalData = nil
|
|
resp.Secret.VaultID = ""
|
|
if !reflect.DeepEqual(resp, expected) {
|
|
t.Fatalf("bad response.\n\nexpected: %#v\n\nGot: %#v", expected, resp)
|
|
}
|
|
}
|
|
|
|
func TestPassthroughBackend_Delete(t *testing.T) {
|
|
b := testPassthroughBackend()
|
|
req := logical.TestRequest(t, logical.WriteOperation, "foo")
|
|
req.Data["raw"] = "test"
|
|
storage := req.Storage
|
|
|
|
if _, err := b.HandleRequest(req); err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
|
|
req = logical.TestRequest(t, logical.DeleteOperation, "foo")
|
|
req.Storage = storage
|
|
resp, err := b.HandleRequest(req)
|
|
if err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
if resp != nil {
|
|
t.Fatalf("bad: %v", resp)
|
|
}
|
|
|
|
req = logical.TestRequest(t, logical.ReadOperation, "foo")
|
|
req.Storage = storage
|
|
resp, err = b.HandleRequest(req)
|
|
if err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
if resp != nil {
|
|
t.Fatalf("bad: %v", resp)
|
|
}
|
|
}
|
|
|
|
func TestPassthroughBackend_List(t *testing.T) {
|
|
b := testPassthroughBackend()
|
|
req := logical.TestRequest(t, logical.WriteOperation, "foo")
|
|
req.Data["raw"] = "test"
|
|
storage := req.Storage
|
|
|
|
if _, err := b.HandleRequest(req); err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
|
|
req = logical.TestRequest(t, logical.ListOperation, "")
|
|
req.Storage = storage
|
|
resp, err := b.HandleRequest(req)
|
|
if err != nil {
|
|
t.Fatalf("err: %v", err)
|
|
}
|
|
|
|
expected := &logical.Response{
|
|
Data: map[string]interface{}{
|
|
"keys": []string{"foo"},
|
|
},
|
|
}
|
|
|
|
if !reflect.DeepEqual(resp, expected) {
|
|
t.Fatalf("bad response.\n\nexpected: %#v\n\nGot: %#v", expected, resp)
|
|
}
|
|
}
|
|
|
|
func testPassthroughBackend() logical.Backend {
|
|
b, _ := PassthroughBackendFactory(nil)
|
|
return b
|
|
}
|