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

     1  //go:build acceptance || keymanager || containers
     2  // +build acceptance keymanager containers
     3  
     4  package v1
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
    10  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    11  	"github.com/gophercloud/gophercloud/openstack/keymanager/v1/containers"
    12  	"github.com/gophercloud/gophercloud/openstack/keymanager/v1/secrets"
    13  	th "github.com/gophercloud/gophercloud/testhelper"
    14  )
    15  
    16  func TestGenericContainersCRUD(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  	payload1 := tools.RandomString("SUPERSECRET-", 8)
    28  	secret1, err := CreateSecretWithPayload(t, client, payload1)
    29  	th.AssertNoErr(t, err)
    30  	secretID1, err := ParseID(secret1.SecretRef)
    31  	th.AssertNoErr(t, err)
    32  	defer DeleteSecret(t, client, secretID1)
    33  
    34  	container, err := CreateGenericContainer(t, client, secret)
    35  	th.AssertNoErr(t, err)
    36  	containerID, err := ParseID(container.ContainerRef)
    37  	th.AssertNoErr(t, err)
    38  	defer DeleteContainer(t, client, containerID)
    39  
    40  	err = ReplaceGenericContainerSecretRef(t, client, container, secret, secret1)
    41  	th.AssertNoErr(t, err)
    42  
    43  	allPages, err := containers.List(client, nil).AllPages()
    44  	th.AssertNoErr(t, err)
    45  
    46  	allContainers, err := containers.ExtractContainers(allPages)
    47  	th.AssertNoErr(t, err)
    48  
    49  	var found bool
    50  	for _, v := range allContainers {
    51  		if v.ContainerRef == container.ContainerRef {
    52  			found = true
    53  		}
    54  	}
    55  
    56  	th.AssertEquals(t, found, true)
    57  }
    58  
    59  func TestCertificateContainer(t *testing.T) {
    60  	client, err := clients.NewKeyManagerV1Client()
    61  	th.AssertNoErr(t, err)
    62  
    63  	pass := tools.RandomString("", 16)
    64  	priv, cert, err := CreateCertificate(t, pass)
    65  	th.AssertNoErr(t, err)
    66  
    67  	private, err := CreatePrivateSecret(t, client, priv)
    68  	th.AssertNoErr(t, err)
    69  	secretID, err := ParseID(private.SecretRef)
    70  	th.AssertNoErr(t, err)
    71  	defer DeleteSecret(t, client, secretID)
    72  
    73  	payload, err := secrets.GetPayload(client, secretID, nil).Extract()
    74  	th.AssertNoErr(t, err)
    75  	t.Logf("Private Payload: %s", string(payload))
    76  
    77  	certificate, err := CreateCertificateSecret(t, client, cert)
    78  	th.AssertNoErr(t, err)
    79  	secretID, err = ParseID(certificate.SecretRef)
    80  	th.AssertNoErr(t, err)
    81  	defer DeleteSecret(t, client, secretID)
    82  
    83  	payload, err = secrets.GetPayload(client, secretID, nil).Extract()
    84  	th.AssertNoErr(t, err)
    85  	t.Logf("Certificate Payload: %s", string(payload))
    86  
    87  	passphrase, err := CreatePassphraseSecret(t, client, pass)
    88  	th.AssertNoErr(t, err)
    89  	secretID, err = ParseID(passphrase.SecretRef)
    90  	th.AssertNoErr(t, err)
    91  	defer DeleteSecret(t, client, secretID)
    92  
    93  	payload, err = secrets.GetPayload(client, secretID, nil).Extract()
    94  	th.AssertNoErr(t, err)
    95  	t.Logf("Passphrase Payload: %s", string(payload))
    96  
    97  	container, err := CreateCertificateContainer(t, client, passphrase, private, certificate)
    98  	th.AssertNoErr(t, err)
    99  	containerID, err := ParseID(container.ContainerRef)
   100  	defer DeleteContainer(t, client, containerID)
   101  }
   102  
   103  func TestRSAContainer(t *testing.T) {
   104  	client, err := clients.NewKeyManagerV1Client()
   105  	th.AssertNoErr(t, err)
   106  
   107  	pass := tools.RandomString("", 16)
   108  	priv, pub, err := CreateRSAKeyPair(t, pass)
   109  	th.AssertNoErr(t, err)
   110  
   111  	private, err := CreatePrivateSecret(t, client, priv)
   112  	th.AssertNoErr(t, err)
   113  	secretID, err := ParseID(private.SecretRef)
   114  	th.AssertNoErr(t, err)
   115  	defer DeleteSecret(t, client, secretID)
   116  
   117  	payload, err := secrets.GetPayload(client, secretID, nil).Extract()
   118  	th.AssertNoErr(t, err)
   119  	t.Logf("Private Payload: %s", string(payload))
   120  
   121  	public, err := CreatePublicSecret(t, client, pub)
   122  	th.AssertNoErr(t, err)
   123  	secretID, err = ParseID(public.SecretRef)
   124  	th.AssertNoErr(t, err)
   125  	defer DeleteSecret(t, client, secretID)
   126  
   127  	payload, err = secrets.GetPayload(client, secretID, nil).Extract()
   128  	th.AssertNoErr(t, err)
   129  	t.Logf("Public Payload: %s", string(payload))
   130  
   131  	passphrase, err := CreatePassphraseSecret(t, client, pass)
   132  	th.AssertNoErr(t, err)
   133  	secretID, err = ParseID(passphrase.SecretRef)
   134  	th.AssertNoErr(t, err)
   135  	defer DeleteSecret(t, client, secretID)
   136  
   137  	payload, err = secrets.GetPayload(client, secretID, nil).Extract()
   138  	th.AssertNoErr(t, err)
   139  	t.Logf("Passphrase Payload: %s", string(payload))
   140  
   141  	container, err := CreateRSAContainer(t, client, passphrase, private, public)
   142  	th.AssertNoErr(t, err)
   143  	containerID, err := ParseID(container.ContainerRef)
   144  	defer DeleteContainer(t, client, containerID)
   145  }
   146  
   147  func TestContainerConsumersCRUD(t *testing.T) {
   148  	client, err := clients.NewKeyManagerV1Client()
   149  	th.AssertNoErr(t, err)
   150  
   151  	payload := tools.RandomString("SUPERSECRET-", 8)
   152  	secret, err := CreateSecretWithPayload(t, client, payload)
   153  	th.AssertNoErr(t, err)
   154  	secretID, err := ParseID(secret.SecretRef)
   155  	th.AssertNoErr(t, err)
   156  	defer DeleteSecret(t, client, secretID)
   157  
   158  	container, err := CreateGenericContainer(t, client, secret)
   159  	th.AssertNoErr(t, err)
   160  	containerID, err := ParseID(container.ContainerRef)
   161  	th.AssertNoErr(t, err)
   162  	defer DeleteContainer(t, client, containerID)
   163  
   164  	consumerName := tools.RandomString("CONSUMER-", 8)
   165  	consumerCreateOpts := containers.CreateConsumerOpts{
   166  		Name: consumerName,
   167  		URL:  "http://example.com",
   168  	}
   169  
   170  	container, err = containers.CreateConsumer(client, containerID, consumerCreateOpts).Extract()
   171  	th.AssertNoErr(t, err)
   172  	tools.PrintResource(t, container.Consumers)
   173  	th.AssertEquals(t, len(container.Consumers), 1)
   174  	defer func() {
   175  		deleteOpts := containers.DeleteConsumerOpts{
   176  			Name: consumerName,
   177  			URL:  "http://example.com",
   178  		}
   179  
   180  		container, err := containers.DeleteConsumer(client, containerID, deleteOpts).Extract()
   181  		th.AssertNoErr(t, err)
   182  		th.AssertEquals(t, len(container.Consumers), 0)
   183  	}()
   184  
   185  	allPages, err := containers.ListConsumers(client, containerID, nil).AllPages()
   186  	th.AssertNoErr(t, err)
   187  
   188  	allConsumers, err := containers.ExtractConsumers(allPages)
   189  	th.AssertNoErr(t, err)
   190  
   191  	var found bool
   192  	for _, v := range allConsumers {
   193  		if v.Name == consumerName {
   194  			found = true
   195  		}
   196  	}
   197  
   198  	th.AssertEquals(t, found, true)
   199  }