github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/keymanager/v1/secrets_test.go (about)

     1  //go:build acceptance || keymanager || secrets
     2  // +build acceptance keymanager secrets
     3  
     4  package v1
     5  
     6  import (
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
    11  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    12  	"github.com/gophercloud/gophercloud/openstack/keymanager/v1/secrets"
    13  	th "github.com/gophercloud/gophercloud/testhelper"
    14  )
    15  
    16  func TestSecretsCRUD(t *testing.T) {
    17  	client, err := clients.NewKeyManagerV1Client()
    18  	th.AssertNoErr(t, err)
    19  
    20  	payload := tools.RandomString("SUPERSECRET-", 8)
    21  	secret, err := CreateSecretWithPayload(t, client, payload)
    22  	th.AssertNoErr(t, err)
    23  	secretID, err := ParseID(secret.SecretRef)
    24  	th.AssertNoErr(t, err)
    25  	defer DeleteSecret(t, client, secretID)
    26  
    27  	// Test payload retrieval
    28  	actual, err := secrets.GetPayload(client, secretID, nil).Extract()
    29  	th.AssertNoErr(t, err)
    30  	th.AssertEquals(t, payload, string(actual))
    31  
    32  	// Test listing secrets
    33  	createdQuery := &secrets.DateQuery{
    34  		Date:   time.Date(2049, 6, 7, 1, 2, 3, 0, time.UTC),
    35  		Filter: secrets.DateFilterLT,
    36  	}
    37  
    38  	listOpts := secrets.ListOpts{
    39  		CreatedQuery: createdQuery,
    40  	}
    41  
    42  	allPages, err := secrets.List(client, listOpts).AllPages()
    43  	th.AssertNoErr(t, err)
    44  
    45  	allSecrets, err := secrets.ExtractSecrets(allPages)
    46  	th.AssertNoErr(t, err)
    47  
    48  	var found bool
    49  	for _, v := range allSecrets {
    50  		if v.SecretRef == secret.SecretRef {
    51  			found = true
    52  		}
    53  	}
    54  
    55  	th.AssertEquals(t, found, true)
    56  }
    57  
    58  func TestSecretsDelayedPayload(t *testing.T) {
    59  	client, err := clients.NewKeyManagerV1Client()
    60  	th.AssertNoErr(t, err)
    61  
    62  	secret, err := CreateEmptySecret(t, client)
    63  	th.AssertNoErr(t, err)
    64  	secretID, err := ParseID(secret.SecretRef)
    65  	th.AssertNoErr(t, err)
    66  	defer DeleteSecret(t, client, secretID)
    67  
    68  	payload := tools.RandomString("SUPERSECRET-", 8)
    69  	updateOpts := secrets.UpdateOpts{
    70  		ContentType: "text/plain",
    71  		Payload:     payload,
    72  	}
    73  
    74  	err = secrets.Update(client, secretID, updateOpts).ExtractErr()
    75  	th.AssertNoErr(t, err)
    76  
    77  	// Test payload retrieval
    78  	actual, err := secrets.GetPayload(client, secretID, nil).Extract()
    79  	th.AssertNoErr(t, err)
    80  	th.AssertEquals(t, payload, string(actual))
    81  }
    82  
    83  func TestSecretsMetadataCRUD(t *testing.T) {
    84  	client, err := clients.NewKeyManagerV1Client()
    85  	th.AssertNoErr(t, err)
    86  
    87  	payload := tools.RandomString("SUPERSECRET-", 8)
    88  	secret, err := CreateSecretWithPayload(t, client, payload)
    89  	th.AssertNoErr(t, err)
    90  	secretID, err := ParseID(secret.SecretRef)
    91  	th.AssertNoErr(t, err)
    92  	defer DeleteSecret(t, client, secretID)
    93  
    94  	// Create some metadata
    95  	createOpts := secrets.MetadataOpts{
    96  		"foo":       "bar",
    97  		"something": "something else",
    98  	}
    99  
   100  	ref, err := secrets.CreateMetadata(client, secretID, createOpts).Extract()
   101  	th.AssertNoErr(t, err)
   102  	th.AssertEquals(t, ref["metadata_ref"], secret.SecretRef+"/metadata")
   103  
   104  	// Get the metadata
   105  	metadata, err := secrets.GetMetadata(client, secretID).Extract()
   106  	th.AssertNoErr(t, err)
   107  	tools.PrintResource(t, metadata)
   108  	th.AssertEquals(t, metadata["foo"], "bar")
   109  	th.AssertEquals(t, metadata["something"], "something else")
   110  
   111  	// Add a single metadatum
   112  	metadatumOpts := secrets.MetadatumOpts{
   113  		Key:   "bar",
   114  		Value: "baz",
   115  	}
   116  
   117  	err = secrets.CreateMetadatum(client, secretID, metadatumOpts).ExtractErr()
   118  	th.AssertNoErr(t, err)
   119  
   120  	metadata, err = secrets.GetMetadata(client, secretID).Extract()
   121  	th.AssertNoErr(t, err)
   122  	tools.PrintResource(t, metadata)
   123  	th.AssertEquals(t, len(metadata), 3)
   124  	th.AssertEquals(t, metadata["foo"], "bar")
   125  	th.AssertEquals(t, metadata["something"], "something else")
   126  	th.AssertEquals(t, metadata["bar"], "baz")
   127  
   128  	// Update a metadatum
   129  	metadatumOpts.Key = "foo"
   130  	metadatumOpts.Value = "foo"
   131  
   132  	metadatum, err := secrets.UpdateMetadatum(client, secretID, metadatumOpts).Extract()
   133  	th.AssertNoErr(t, err)
   134  	tools.PrintResource(t, metadatum)
   135  	th.AssertDeepEquals(t, metadatum.Key, "foo")
   136  	th.AssertDeepEquals(t, metadatum.Value, "foo")
   137  
   138  	metadata, err = secrets.GetMetadata(client, secretID).Extract()
   139  	th.AssertNoErr(t, err)
   140  	tools.PrintResource(t, metadata)
   141  	th.AssertEquals(t, len(metadata), 3)
   142  	th.AssertEquals(t, metadata["foo"], "foo")
   143  	th.AssertEquals(t, metadata["something"], "something else")
   144  	th.AssertEquals(t, metadata["bar"], "baz")
   145  
   146  	// Delete a metadatum
   147  	err = secrets.DeleteMetadatum(client, secretID, "foo").ExtractErr()
   148  	th.AssertNoErr(t, err)
   149  
   150  	metadata, err = secrets.GetMetadata(client, secretID).Extract()
   151  	th.AssertNoErr(t, err)
   152  	tools.PrintResource(t, metadata)
   153  	th.AssertEquals(t, len(metadata), 2)
   154  	th.AssertEquals(t, metadata["something"], "something else")
   155  	th.AssertEquals(t, metadata["bar"], "baz")
   156  }
   157  
   158  func TestSymmetricSecret(t *testing.T) {
   159  	client, err := clients.NewKeyManagerV1Client()
   160  	th.AssertNoErr(t, err)
   161  
   162  	secret, err := CreateSymmetricSecret(t, client)
   163  	th.AssertNoErr(t, err)
   164  	secretID, err := ParseID(secret.SecretRef)
   165  	th.AssertNoErr(t, err)
   166  	defer DeleteSecret(t, client, secretID)
   167  
   168  	payload, err := secrets.GetPayload(client, secretID, nil).Extract()
   169  	th.AssertNoErr(t, err)
   170  	tools.PrintResource(t, string(payload))
   171  }
   172  
   173  func TestCertificateSecret(t *testing.T) {
   174  	client, err := clients.NewKeyManagerV1Client()
   175  	th.AssertNoErr(t, err)
   176  
   177  	pass := tools.RandomString("", 16)
   178  	cert, _, err := CreateCertificate(t, pass)
   179  	th.AssertNoErr(t, err)
   180  
   181  	secret, err := CreateCertificateSecret(t, client, cert)
   182  	th.AssertNoErr(t, err)
   183  	secretID, err := ParseID(secret.SecretRef)
   184  	th.AssertNoErr(t, err)
   185  	defer DeleteSecret(t, client, secretID)
   186  
   187  	payload, err := secrets.GetPayload(client, secretID, nil).Extract()
   188  	th.AssertNoErr(t, err)
   189  	tools.PrintResource(t, string(payload))
   190  }
   191  
   192  func TestPrivateSecret(t *testing.T) {
   193  	client, err := clients.NewKeyManagerV1Client()
   194  	th.AssertNoErr(t, err)
   195  
   196  	pass := tools.RandomString("", 16)
   197  	priv, _, err := CreateCertificate(t, pass)
   198  	th.AssertNoErr(t, err)
   199  
   200  	secret, err := CreatePrivateSecret(t, client, priv)
   201  	th.AssertNoErr(t, err)
   202  	secretID, err := ParseID(secret.SecretRef)
   203  	th.AssertNoErr(t, err)
   204  	defer DeleteSecret(t, client, secretID)
   205  
   206  	payload, err := secrets.GetPayload(client, secretID, nil).Extract()
   207  	th.AssertNoErr(t, err)
   208  	tools.PrintResource(t, string(payload))
   209  }
   210  
   211  func TestPublicSecret(t *testing.T) {
   212  	client, err := clients.NewKeyManagerV1Client()
   213  	th.AssertNoErr(t, err)
   214  
   215  	_, pub, err := CreateRSAKeyPair(t, "")
   216  	th.AssertNoErr(t, err)
   217  
   218  	secret, err := CreatePublicSecret(t, client, pub)
   219  	th.AssertNoErr(t, err)
   220  	secretID, err := ParseID(secret.SecretRef)
   221  	th.AssertNoErr(t, err)
   222  	defer DeleteSecret(t, client, secretID)
   223  
   224  	payload, err := secrets.GetPayload(client, secretID, nil).Extract()
   225  	th.AssertNoErr(t, err)
   226  	tools.PrintResource(t, string(payload))
   227  }
   228  
   229  func TestPassphraseSecret(t *testing.T) {
   230  	client, err := clients.NewKeyManagerV1Client()
   231  	th.AssertNoErr(t, err)
   232  
   233  	pass := tools.RandomString("", 16)
   234  	secret, err := CreatePassphraseSecret(t, client, pass)
   235  	th.AssertNoErr(t, err)
   236  	secretID, err := ParseID(secret.SecretRef)
   237  	th.AssertNoErr(t, err)
   238  	defer DeleteSecret(t, client, secretID)
   239  
   240  	payload, err := secrets.GetPayload(client, secretID, nil).Extract()
   241  	th.AssertNoErr(t, err)
   242  	tools.PrintResource(t, string(payload))
   243  }