github.com/vnpaycloud-console/gophercloud/v2@v2.0.5/internal/acceptance/openstack/compute/v2/keypairs_test.go (about)

     1  //go:build acceptance || compute || keypairs
     2  
     3  package v2
     4  
     5  import (
     6  	"context"
     7  	"testing"
     8  
     9  	"github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/clients"
    10  	identity "github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/openstack/identity/v3"
    11  	"github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/tools"
    12  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/compute/v2/keypairs"
    13  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/compute/v2/servers"
    14  	th "github.com/vnpaycloud-console/gophercloud/v2/testhelper"
    15  	"golang.org/x/crypto/ssh"
    16  )
    17  
    18  func TestKeyPairsParse(t *testing.T) {
    19  	client, err := clients.NewComputeV2Client()
    20  	th.AssertNoErr(t, err)
    21  
    22  	keyPair, err := CreateKeyPair(t, client)
    23  	th.AssertNoErr(t, err)
    24  	defer DeleteKeyPair(t, client, keyPair)
    25  
    26  	// There was a series of OpenStack releases, between Liberty and Ocata,
    27  	// where the returned SSH key was not parsable by Go.
    28  	// This checks if the issue is happening again.
    29  	_, err = ssh.ParsePrivateKey([]byte(keyPair.PrivateKey))
    30  	th.AssertNoErr(t, err)
    31  
    32  	tools.PrintResource(t, keyPair)
    33  }
    34  
    35  func TestKeyPairsCreateDelete(t *testing.T) {
    36  	client, err := clients.NewComputeV2Client()
    37  	th.AssertNoErr(t, err)
    38  
    39  	keyPair, err := CreateKeyPair(t, client)
    40  	th.AssertNoErr(t, err)
    41  	defer DeleteKeyPair(t, client, keyPair)
    42  
    43  	tools.PrintResource(t, keyPair)
    44  
    45  	allPages, err := keypairs.List(client, nil).AllPages(context.TODO())
    46  	th.AssertNoErr(t, err)
    47  
    48  	allKeys, err := keypairs.ExtractKeyPairs(allPages)
    49  	th.AssertNoErr(t, err)
    50  
    51  	var found bool
    52  	for _, kp := range allKeys {
    53  		tools.PrintResource(t, kp)
    54  
    55  		if kp.Name == keyPair.Name {
    56  			found = true
    57  		}
    58  	}
    59  
    60  	th.AssertEquals(t, true, found)
    61  }
    62  
    63  func TestKeyPairsImportPublicKey(t *testing.T) {
    64  	client, err := clients.NewComputeV2Client()
    65  	th.AssertNoErr(t, err)
    66  
    67  	publicKey, err := createKey()
    68  	th.AssertNoErr(t, err)
    69  
    70  	keyPair, err := ImportPublicKey(t, client, publicKey)
    71  	th.AssertNoErr(t, err)
    72  	defer DeleteKeyPair(t, client, keyPair)
    73  
    74  	tools.PrintResource(t, keyPair)
    75  }
    76  
    77  func TestKeyPairsServerCreateWithKey(t *testing.T) {
    78  	clients.RequireLong(t)
    79  
    80  	client, err := clients.NewComputeV2Client()
    81  	th.AssertNoErr(t, err)
    82  
    83  	publicKey, err := createKey()
    84  	th.AssertNoErr(t, err)
    85  
    86  	keyPair, err := ImportPublicKey(t, client, publicKey)
    87  	th.AssertNoErr(t, err)
    88  	defer DeleteKeyPair(t, client, keyPair)
    89  
    90  	server, err := CreateServerWithPublicKey(t, client, keyPair.Name)
    91  	th.AssertNoErr(t, err)
    92  	defer DeleteServer(t, client, server)
    93  
    94  	server, err = servers.Get(context.TODO(), client, server.ID).Extract()
    95  	th.AssertNoErr(t, err)
    96  
    97  	th.AssertEquals(t, keyPair.Name, server.KeyName)
    98  }
    99  
   100  func TestKeyPairsCreateDeleteByID(t *testing.T) {
   101  	clients.RequireAdmin(t)
   102  
   103  	identityClient, err := clients.NewIdentityV3Client()
   104  	th.AssertNoErr(t, err)
   105  
   106  	computeClient, err := clients.NewComputeV2Client()
   107  	th.AssertNoErr(t, err)
   108  
   109  	computeClient.Microversion = "2.10"
   110  
   111  	user, err := identity.CreateUser(t, identityClient, nil)
   112  	th.AssertNoErr(t, err)
   113  	defer identity.DeleteUser(t, identityClient, user.ID)
   114  
   115  	keyPairName := tools.RandomString("keypair_", 5)
   116  	createOpts := keypairs.CreateOpts{
   117  		Name:   keyPairName,
   118  		UserID: user.ID,
   119  	}
   120  
   121  	keyPair, err := keypairs.Create(context.TODO(), computeClient, createOpts).Extract()
   122  	th.AssertNoErr(t, err)
   123  
   124  	getOpts := keypairs.GetOpts{
   125  		UserID: user.ID,
   126  	}
   127  
   128  	newKeyPair, err := keypairs.Get(context.TODO(), computeClient, keyPair.Name, getOpts).Extract()
   129  	th.AssertNoErr(t, err)
   130  	th.AssertEquals(t, keyPair.Name, newKeyPair.Name)
   131  
   132  	listOpts := keypairs.ListOpts{
   133  		UserID: user.ID,
   134  	}
   135  
   136  	allPages, err := keypairs.List(computeClient, listOpts).AllPages(context.TODO())
   137  	th.AssertNoErr(t, err)
   138  
   139  	allKeys, err := keypairs.ExtractKeyPairs(allPages)
   140  	th.AssertNoErr(t, err)
   141  
   142  	var found bool
   143  	for _, kp := range allKeys {
   144  		if kp.Name == keyPair.Name {
   145  			found = true
   146  		}
   147  	}
   148  
   149  	th.AssertEquals(t, true, found)
   150  
   151  	deleteOpts := keypairs.DeleteOpts{
   152  		UserID: user.ID,
   153  	}
   154  
   155  	err = keypairs.Delete(context.TODO(), computeClient, keyPair.Name, deleteOpts).ExtractErr()
   156  	th.AssertNoErr(t, err)
   157  }