github.com/vnpaycloud-console/gophercloud/v2@v2.0.5/internal/acceptance/openstack/keymanager/v1/containers_test.go (about)

     1  //go:build acceptance || keymanager || containers
     2  
     3  package v1
     4  
     5  import (
     6  	"context"
     7  	"testing"
     8  
     9  	"github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/clients"
    10  	"github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/tools"
    11  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/keymanager/v1/containers"
    12  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/keymanager/v1/secrets"
    13  	th "github.com/vnpaycloud-console/gophercloud/v2/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(context.TODO())
    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(context.TODO(), 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(context.TODO(), 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(context.TODO(), 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  	th.AssertNoErr(t, err)
   101  	defer DeleteContainer(t, client, containerID)
   102  }
   103  
   104  func TestRSAContainer(t *testing.T) {
   105  	client, err := clients.NewKeyManagerV1Client()
   106  	th.AssertNoErr(t, err)
   107  
   108  	pass := tools.RandomString("", 16)
   109  	priv, pub, err := CreateRSAKeyPair(t, pass)
   110  	th.AssertNoErr(t, err)
   111  
   112  	private, err := CreatePrivateSecret(t, client, priv)
   113  	th.AssertNoErr(t, err)
   114  	secretID, err := ParseID(private.SecretRef)
   115  	th.AssertNoErr(t, err)
   116  	defer DeleteSecret(t, client, secretID)
   117  
   118  	payload, err := secrets.GetPayload(context.TODO(), client, secretID, nil).Extract()
   119  	th.AssertNoErr(t, err)
   120  	t.Logf("Private Payload: %s", string(payload))
   121  
   122  	public, err := CreatePublicSecret(t, client, pub)
   123  	th.AssertNoErr(t, err)
   124  	secretID, err = ParseID(public.SecretRef)
   125  	th.AssertNoErr(t, err)
   126  	defer DeleteSecret(t, client, secretID)
   127  
   128  	payload, err = secrets.GetPayload(context.TODO(), client, secretID, nil).Extract()
   129  	th.AssertNoErr(t, err)
   130  	t.Logf("Public Payload: %s", string(payload))
   131  
   132  	passphrase, err := CreatePassphraseSecret(t, client, pass)
   133  	th.AssertNoErr(t, err)
   134  	secretID, err = ParseID(passphrase.SecretRef)
   135  	th.AssertNoErr(t, err)
   136  	defer DeleteSecret(t, client, secretID)
   137  
   138  	payload, err = secrets.GetPayload(context.TODO(), client, secretID, nil).Extract()
   139  	th.AssertNoErr(t, err)
   140  	t.Logf("Passphrase Payload: %s", string(payload))
   141  
   142  	container, err := CreateRSAContainer(t, client, passphrase, private, public)
   143  	th.AssertNoErr(t, err)
   144  	containerID, err := ParseID(container.ContainerRef)
   145  	th.AssertNoErr(t, err)
   146  	defer DeleteContainer(t, client, containerID)
   147  }
   148  
   149  func TestContainerConsumersCRUD(t *testing.T) {
   150  	client, err := clients.NewKeyManagerV1Client()
   151  	th.AssertNoErr(t, err)
   152  
   153  	payload := tools.RandomString("SUPERSECRET-", 8)
   154  	secret, err := CreateSecretWithPayload(t, client, payload)
   155  	th.AssertNoErr(t, err)
   156  	secretID, err := ParseID(secret.SecretRef)
   157  	th.AssertNoErr(t, err)
   158  	defer DeleteSecret(t, client, secretID)
   159  
   160  	container, err := CreateGenericContainer(t, client, secret)
   161  	th.AssertNoErr(t, err)
   162  	containerID, err := ParseID(container.ContainerRef)
   163  	th.AssertNoErr(t, err)
   164  	defer DeleteContainer(t, client, containerID)
   165  
   166  	consumerName := tools.RandomString("CONSUMER-", 8)
   167  	consumerCreateOpts := containers.CreateConsumerOpts{
   168  		Name: consumerName,
   169  		URL:  "http://example.com",
   170  	}
   171  
   172  	container, err = containers.CreateConsumer(context.TODO(), client, containerID, consumerCreateOpts).Extract()
   173  	th.AssertNoErr(t, err)
   174  	tools.PrintResource(t, container.Consumers)
   175  	th.AssertEquals(t, len(container.Consumers), 1)
   176  	defer func() {
   177  		deleteOpts := containers.DeleteConsumerOpts{
   178  			Name: consumerName,
   179  			URL:  "http://example.com",
   180  		}
   181  
   182  		container, err := containers.DeleteConsumer(context.TODO(), client, containerID, deleteOpts).Extract()
   183  		th.AssertNoErr(t, err)
   184  		th.AssertEquals(t, len(container.Consumers), 0)
   185  	}()
   186  
   187  	allPages, err := containers.ListConsumers(client, containerID, nil).AllPages(context.TODO())
   188  	th.AssertNoErr(t, err)
   189  
   190  	allConsumers, err := containers.ExtractConsumers(allPages)
   191  	th.AssertNoErr(t, err)
   192  
   193  	var found bool
   194  	for _, v := range allConsumers {
   195  		if v.Name == consumerName {
   196  			found = true
   197  		}
   198  	}
   199  
   200  	th.AssertEquals(t, found, true)
   201  }