github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/compute/v2/keypairs_test.go (about)

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