625 lines
19 KiB
Go
625 lines
19 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
logicalKv "github.com/hashicorp/vault-plugin-secrets-kv"
|
|
"github.com/hashicorp/vault/api"
|
|
vaulthttp "github.com/hashicorp/vault/http"
|
|
"github.com/hashicorp/vault/sdk/logical"
|
|
"github.com/hashicorp/vault/vault"
|
|
)
|
|
|
|
const (
|
|
v1MountPath = "secret"
|
|
v2MountPath = "secret-v2"
|
|
secretPath = "my-secret"
|
|
)
|
|
|
|
var (
|
|
client *api.Client
|
|
secretData = map[string]interface{}{
|
|
"foo": "bar",
|
|
}
|
|
)
|
|
|
|
// setupKVv2Test creates the secret that will be used in each KV v2 subtest. It
|
|
// returns a function (that should be deferred whenever setupKVv2Test is called)
|
|
// which will perform the cleanup of all existing versions of the secret, as
|
|
// well as the secret that was written for comparison.
|
|
func setupKVv2Test(t *testing.T) (func(t *testing.T), *api.KVSecret) {
|
|
writtenSecret, err := client.KVv2(v2MountPath).Put(context.Background(), secretPath, secretData)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if writtenSecret == nil || writtenSecret.VersionMetadata == nil {
|
|
t.Fatal("secret created during kv v2 subtest setup did not have expected contents")
|
|
}
|
|
|
|
return func(t *testing.T) {
|
|
err := client.KVv2(v2MountPath).DeleteMetadata(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}, writtenSecret
|
|
}
|
|
|
|
func TestKVHelpers(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// initialize test cluster
|
|
coreConfig := &vault.CoreConfig{
|
|
LogicalBackends: map[string]logical.Factory{
|
|
"kv": logicalKv.Factory,
|
|
"kv-v2": logicalKv.VersionedKVFactory,
|
|
},
|
|
}
|
|
|
|
cluster := vault.NewTestCluster(t, coreConfig, &vault.TestClusterOptions{
|
|
HandlerFunc: vaulthttp.Handler,
|
|
})
|
|
|
|
cluster.Start()
|
|
defer cluster.Cleanup()
|
|
|
|
cores := cluster.Cores
|
|
core := cores[0].Core
|
|
client = cluster.Cores[0].Client
|
|
vault.TestWaitActive(t, core)
|
|
|
|
// mount the KVv2 backend
|
|
// (the test cluster has already mounted the KVv1 backend at "secret")
|
|
err := client.Sys().MountWithContext(context.Background(), "secret-v2", &api.MountInput{
|
|
Type: "kv-v2",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
//// v1 ////
|
|
t.Run("kv v1: put, get, and delete data", func(t *testing.T) {
|
|
if err := client.KVv1(v1MountPath).Put(context.Background(), secretPath, secretData); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
secret, err := client.KVv1(v1MountPath).Get(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if secret.Data["foo"] != "bar" {
|
|
t.Fatalf("kv v1 secret did not contain expected value")
|
|
}
|
|
|
|
if err := client.KVv1(v1MountPath).Delete(context.Background(), secretPath); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, err = client.KVv1(v1MountPath).Get(context.Background(), secretPath)
|
|
if !errors.Is(err, api.ErrSecretNotFound) {
|
|
t.Fatalf("KVv1.Get is expected to return an api.ErrSecretNotFound wrapped error after secret had been deleted; got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("kv v1: get secret that does not exist", func(t *testing.T) {
|
|
_, err = client.KVv1(v1MountPath).Get(context.Background(), "does/not/exist")
|
|
if err == nil {
|
|
t.Fatalf("KVv1.Get is expected to return an error for a missing secret")
|
|
}
|
|
if !errors.Is(err, api.ErrSecretNotFound) {
|
|
t.Fatalf("KVv1.Get is expected to return an api.ErrSecretNotFound wrapped error for a missing secret; got %v", err)
|
|
}
|
|
})
|
|
|
|
//// v2 ////
|
|
t.Run("kv v2: get data and full metadata", func(t *testing.T) {
|
|
teardownTest, originalSecret := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
secret, err := client.KVv2(v2MountPath).Get(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if secret.Data["foo"] != "bar" {
|
|
t.Fatal("kv v2 secret did not contain expected value")
|
|
}
|
|
if secret.VersionMetadata.CreatedTime != originalSecret.VersionMetadata.CreatedTime {
|
|
t.Fatal("the created_time on the secret did not match the response from when it was created")
|
|
}
|
|
|
|
// get its full metadata
|
|
fullMetadata, err := client.KVv2(v2MountPath).GetMetadata(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(secret.CustomMetadata, fullMetadata.CustomMetadata) {
|
|
t.Fatalf("custom metadata on the secret does not match the custom metadata in the full metadata")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: get secret that does not exist", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
_, err = client.KVv2(v1MountPath).Get(context.Background(), "does/not/exist")
|
|
if !errors.Is(err, api.ErrSecretNotFound) {
|
|
t.Fatalf("KVv2.Get is expected to return an api.ErrSecretNotFound wrapped error for a missing secret; got %v", err)
|
|
}
|
|
|
|
_, err = client.KVv2(v1MountPath).GetMetadata(context.Background(), "does/not/exist")
|
|
if !errors.Is(err, api.ErrSecretNotFound) {
|
|
t.Fatalf("KVv2.GetMetadata is expected to return an api.ErrSecretNotFound wrapped error for a missing secret; got %v", err)
|
|
}
|
|
|
|
_, err = client.KVv2(v1MountPath).GetVersion(context.Background(), secretPath, 99)
|
|
if !errors.Is(err, api.ErrSecretNotFound) {
|
|
t.Fatalf("KVv2.GetVersion is expected to return an api.ErrSecretNotFound wrapped error for a missing secret version; got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: multiple versions", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
// create a second version
|
|
_, err = client.KVv2(v2MountPath).Put(context.Background(), secretPath, map[string]interface{}{
|
|
"foo": "baz",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
s2, err := client.KVv2(v2MountPath).Get(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if s2.Data["foo"] != "baz" {
|
|
t.Fatalf("second version of secret did not have expected contents")
|
|
}
|
|
if s2.VersionMetadata.Version != 2 {
|
|
t.Fatalf("wrong version of kv v2 secret was read, expected 2 but got %d", s2.VersionMetadata.Version)
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: delete and undelete", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
// create a second version
|
|
_, err = client.KVv2(v2MountPath).Put(context.Background(), secretPath, map[string]interface{}{
|
|
"foo": "baz",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// get a specific past version
|
|
s1, err := client.KVv2(v2MountPath).GetVersion(context.Background(), secretPath, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if s1.VersionMetadata.Version != 1 {
|
|
t.Fatalf("wrong version of kv v2 secret was read, expected 1 but got %d", s1.VersionMetadata.Version)
|
|
}
|
|
|
|
// delete that version
|
|
if err = client.KVv2(v2MountPath).DeleteVersions(context.Background(), secretPath, []int{1}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
s1AfterDelete, err := client.KVv2(v2MountPath).GetVersion(context.Background(), secretPath, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if s1AfterDelete.VersionMetadata.DeletionTime.IsZero() {
|
|
t.Fatalf("the deletion_time in the first version of the secret was not updated")
|
|
}
|
|
|
|
if s1AfterDelete.Data != nil {
|
|
t.Fatalf("data still exists on the first version of the secret despite this version being deleted")
|
|
}
|
|
|
|
// undelete it
|
|
err = client.KVv2(v2MountPath).Undelete(context.Background(), secretPath, []int{1})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
s1AfterUndelete, err := client.KVv2(v2MountPath).GetVersion(context.Background(), secretPath, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if s1AfterUndelete.Data == nil {
|
|
t.Fatalf("data is empty for the first version of the secret despite this version being undeleted")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: destroy", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
err = client.KVv2(v2MountPath).Destroy(context.Background(), secretPath, []int{1})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
destroyedSecret, err := client.KVv2(v2MountPath).Get(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !destroyedSecret.VersionMetadata.Destroyed {
|
|
t.Fatalf("expected secret to be destroyed but it wasn't")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: use named functional options and generic WithOption", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
// check that KVOption works
|
|
// WithCheckAndSet
|
|
_, err = client.KVv2(v2MountPath).Put(context.Background(), secretPath, map[string]interface{}{
|
|
"meow": "woof",
|
|
}, api.WithCheckAndSet(99))
|
|
// should fail
|
|
if err == nil {
|
|
t.Fatalf("expected error from trying to update different version from check-and-set value using WithCheckAndSet")
|
|
}
|
|
|
|
// WithOption (generic)
|
|
_, err = client.KVv2(v2MountPath).Put(context.Background(), secretPath, map[string]interface{}{
|
|
"bow": "wow",
|
|
}, api.WithOption("cas", 99))
|
|
// should fail
|
|
if err == nil {
|
|
t.Fatalf("expected error from trying to update different version from check-and-set value using generic WithOption")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: patch", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
// WithMergeMethod Patch (implicit)
|
|
patch, err := client.KVv2(v2MountPath).Patch(context.Background(), secretPath, map[string]interface{}{
|
|
"dog": "cat",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if patch.VersionMetadata.Version != 2 {
|
|
t.Fatalf("incorrect version %d, expected 2", patch.VersionMetadata.Version)
|
|
}
|
|
|
|
// WithMergeMethod Patch (explicit)
|
|
patchExp, err := client.KVv2(v2MountPath).Patch(context.Background(), secretPath, map[string]interface{}{
|
|
"rat": "mouse",
|
|
}, api.WithMergeMethod(api.KVMergeMethodPatch))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if patchExp.VersionMetadata.Version != 3 {
|
|
t.Fatalf("incorrect version %d, expected 3", patchExp.VersionMetadata.Version)
|
|
}
|
|
|
|
// WithMergeMethod RW
|
|
patchRW, err := client.KVv2(v2MountPath).Patch(context.Background(), secretPath, map[string]interface{}{
|
|
"bird": "tweet",
|
|
}, api.WithMergeMethod(api.KVMergeMethodReadWrite))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if patchRW.VersionMetadata.Version != 4 {
|
|
t.Fatalf("incorrect version %d, expected 4", patchRW.VersionMetadata.Version)
|
|
}
|
|
|
|
secretAfterPatches, err := client.KVv2(v2MountPath).Get(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, ok := secretAfterPatches.Data["dog"]
|
|
if !ok {
|
|
t.Fatalf("secret did not contain data patched with implicit Patch method")
|
|
}
|
|
_, ok = secretAfterPatches.Data["rat"]
|
|
if !ok {
|
|
t.Fatalf("secret did not contain data patched with explicit Patch method")
|
|
}
|
|
_, ok = secretAfterPatches.Data["bird"]
|
|
if !ok {
|
|
t.Fatalf("secret did not contain data patched with RW method")
|
|
}
|
|
value, ok := secretAfterPatches.Data["foo"]
|
|
if !ok || value != "bar" {
|
|
t.Fatalf("secret did not keep original data after patch")
|
|
}
|
|
|
|
// patch an existing field
|
|
_, err = client.KVv2(v2MountPath).Patch(context.Background(), secretPath, map[string]interface{}{
|
|
"dog": "pug",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
patchedFieldKV, err := client.KVv2(v2MountPath).Get(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
v, ok := patchedFieldKV.Data["dog"]
|
|
if !ok || v != "pug" {
|
|
t.Fatalf("secret's data was not replaced by patch")
|
|
}
|
|
|
|
// delete a key in a secret via patch
|
|
_, err = client.KVv2(v2MountPath).Patch(context.Background(), secretPath, map[string]interface{}{
|
|
"dog": nil,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
deletedFieldKV, err := client.KVv2(v2MountPath).Get(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, ok = deletedFieldKV.Data["dog"]
|
|
if ok {
|
|
t.Fatalf("secret key \"dog\" should have been removed by nil patch")
|
|
}
|
|
|
|
// set a key to an empty string via patch
|
|
_, err = client.KVv2(v2MountPath).Patch(context.Background(), secretPath, map[string]interface{}{
|
|
"dog": "",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
emptyValueKV, err := client.KVv2(v2MountPath).Get(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
v, ok = emptyValueKV.Data["dog"]
|
|
if !ok || v != "" {
|
|
t.Fatalf("secret key \"dog\" should have an empty string value")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: patch a secret that does not exist", func(t *testing.T) {
|
|
for _, method := range [][]api.KVOption{
|
|
{},
|
|
{api.WithMergeMethod(api.KVMergeMethodPatch)},
|
|
{api.WithMergeMethod(api.KVMergeMethodReadWrite)},
|
|
} {
|
|
_, err = client.KVv2(v2MountPath).Patch(
|
|
context.Background(),
|
|
"does/not/exist",
|
|
map[string]interface{}{"no": "nope"},
|
|
method...,
|
|
)
|
|
if !errors.Is(err, api.ErrSecretNotFound) {
|
|
t.Fatalf("expected an api.ErrSecretNotFound wrapped error from trying to patch something that doesn't exist for %v method; got: %v", method, err)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: roll back to an old version", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
// create a second version
|
|
_, err = client.KVv2(v2MountPath).Put(context.Background(), secretPath, map[string]interface{}{
|
|
"color": "yellow",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// get versions as list
|
|
versions, err := client.KVv2(v2MountPath).GetVersionsAsList(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectedLength := 2
|
|
if len(versions) != expectedLength {
|
|
t.Fatalf("expected there to be %d versions of the secret but got %d", expectedLength, len(versions))
|
|
}
|
|
|
|
if versions[0].Version != 1 || versions[len(versions)-1].Version != expectedLength {
|
|
t.Fatalf("versions list is not ordered as expected")
|
|
}
|
|
|
|
// roll back to version 1
|
|
rb, err := client.KVv2(v2MountPath).Rollback(context.Background(), secretPath, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if rb.VersionMetadata.Version != 3 {
|
|
t.Fatalf("expected returned secret's version %d to be the latest version, which should be 3", rb.VersionMetadata.Version)
|
|
}
|
|
|
|
// destroy version 1
|
|
err = client.KVv2(v2MountPath).Destroy(context.Background(), secretPath, []int{1})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// roll back but fail
|
|
_, err = client.KVv2(v2MountPath).Rollback(context.Background(), secretPath, 1)
|
|
if err == nil {
|
|
t.Fatalf("expected error from trying to rollback to destroyed version")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: delete all versions of a secret", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
// create a second version
|
|
_, err = client.KVv2(v2MountPath).Put(context.Background(), secretPath, map[string]interface{}{
|
|
"color": "yellow",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// delete it all
|
|
err = client.KVv2(v2MountPath).DeleteMetadata(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
versions, err := client.KVv2(v2MountPath).GetVersionsAsList(context.Background(), secretPath)
|
|
if err == nil {
|
|
t.Fatalf("expected to be unable to get list of versions since all metadata was destroyed")
|
|
}
|
|
if len(versions) > 0 {
|
|
t.Fatalf("expected no versions of secret after deleting all metadata")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: create a secret with metadata but no data", func(t *testing.T) {
|
|
// put and patch metadata
|
|
////
|
|
noDataSecretPath := "empty"
|
|
|
|
// create a secret with metadata but no data
|
|
err = client.KVv2(v2MountPath).PutMetadata(context.Background(), noDataSecretPath, api.KVMetadataPutInput{
|
|
DeleteVersionAfter: 5 * time.Hour,
|
|
MaxVersions: 5,
|
|
CustomMetadata: map[string]interface{}{"ape": "gorilla"},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// get its metadata to make sure it was created successfully
|
|
md, err := client.KVv2(v2MountPath).GetMetadata(context.Background(), noDataSecretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if md.CreatedTime.IsZero() {
|
|
t.Fatalf("secret metadata was not populated as expected: %v", err)
|
|
}
|
|
if len(md.Versions) > 0 {
|
|
t.Fatalf("no secret versions should have been created since only metadata was populated")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: put and patch metadata", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
md, err := client.KVv2(v2MountPath).GetMetadata(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// replace all modifiable metadata fields
|
|
err = client.KVv2(v2MountPath).PutMetadata(context.Background(), secretPath, api.KVMetadataPutInput{
|
|
CASRequired: true,
|
|
DeleteVersionAfter: 6 * time.Hour,
|
|
MaxVersions: 6,
|
|
CustomMetadata: map[string]interface{}{"foo": "fwah", "cat": "tabby"},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// check that metadata was replaced
|
|
md2, err := client.KVv2(v2MountPath).GetMetadata(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if md.CASRequired == md2.CASRequired || md.MaxVersions == md2.MaxVersions || md.DeleteVersionAfter == md2.DeleteVersionAfter || reflect.DeepEqual(md.CustomMetadata, md2.CustomMetadata) {
|
|
t.Fatalf("metadata fields should have been updated by PutMetadata")
|
|
}
|
|
|
|
// now let's try a patch
|
|
maxVersions := 7
|
|
err = client.KVv2(v2MountPath).PatchMetadata(context.Background(), secretPath, api.KVMetadataPatchInput{
|
|
MaxVersions: &maxVersions,
|
|
CustomMetadata: map[string]interface{}{"foo": nil, "rat": "brown"},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// check that the metadata was only partially replaced
|
|
md3, err := client.KVv2(v2MountPath).GetMetadata(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if md2.CASRequired != md3.CASRequired || md2.DeleteVersionAfter != md3.DeleteVersionAfter {
|
|
t.Fatalf("expected fields to remain unchanged but they were updated")
|
|
}
|
|
if md3.MaxVersions == 0 {
|
|
t.Fatalf("field was reset to its zero value when it should not have been")
|
|
}
|
|
if md2.MaxVersions == md3.MaxVersions {
|
|
t.Fatalf("expected field to be updated but it remained unchanged")
|
|
}
|
|
|
|
// let's check the custom metadata was updated correctly
|
|
if r, ok := md3.CustomMetadata["rat"]; ok {
|
|
if r != "brown" {
|
|
t.Fatalf("expected value to be \"brown\"")
|
|
}
|
|
} else {
|
|
t.Fatalf("expected there to be a new \"rat\" key")
|
|
}
|
|
|
|
if _, ok := md3.CustomMetadata["foo"]; ok {
|
|
t.Fatalf("expected \"foo\" key to be removed")
|
|
}
|
|
|
|
if _, ok := md3.CustomMetadata["cat"]; !ok {
|
|
t.Fatalf("did not expect \"cat\" key to be removed")
|
|
}
|
|
})
|
|
|
|
t.Run("kv v2: patch with explicit zero values", func(t *testing.T) {
|
|
teardownTest, _ := setupKVv2Test(t)
|
|
defer teardownTest(t)
|
|
|
|
// now let's do another patch to test the "explicit zero value" use case
|
|
var (
|
|
explicitFalse bool
|
|
explicitZero int
|
|
explicitTimeZero time.Duration
|
|
)
|
|
err = client.KVv2(v2MountPath).PatchMetadata(context.Background(), secretPath, api.KVMetadataPatchInput{
|
|
CASRequired: &explicitFalse,
|
|
MaxVersions: &explicitZero,
|
|
DeleteVersionAfter: &explicitTimeZero,
|
|
CustomMetadata: map[string]interface{}{},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// check that those fields were reset to their zero value
|
|
md4, err := client.KVv2(v2MountPath).GetMetadata(context.Background(), secretPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(md4.CustomMetadata) > 0 {
|
|
t.Fatalf("expected empty map to cause deletion of all custom metadata")
|
|
}
|
|
|
|
if md4.MaxVersions != 0 || md4.CASRequired != false {
|
|
t.Fatalf("expected fields to be reset to their zero values but they were %d and %t instead", md4.MaxVersions, md4.CASRequired)
|
|
}
|
|
|
|
if md4.DeleteVersionAfter.String() != "0s" {
|
|
t.Fatalf("expected delete-version-after to be reset to its zero value but instead it was %s", md4.DeleteVersionAfter.String())
|
|
}
|
|
})
|
|
}
|