github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/blockstorage/extensions/volumeactions_test.go (about)

     1  //go:build acceptance || blockstorage
     2  // +build acceptance blockstorage
     3  
     4  package extensions
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
    10  	blockstorage "github.com/gophercloud/gophercloud/internal/acceptance/openstack/blockstorage/v2"
    11  	blockstorageV3 "github.com/gophercloud/gophercloud/internal/acceptance/openstack/blockstorage/v3"
    12  	compute "github.com/gophercloud/gophercloud/internal/acceptance/openstack/compute/v2"
    13  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    14  	"github.com/gophercloud/gophercloud/openstack/blockstorage/v2/volumes"
    15  	th "github.com/gophercloud/gophercloud/testhelper"
    16  )
    17  
    18  func TestVolumeActionsUploadImageDestroy(t *testing.T) {
    19  	blockClient, err := clients.NewBlockStorageV3Client()
    20  	th.AssertNoErr(t, err)
    21  
    22  	computeClient, err := clients.NewComputeV2Client()
    23  	th.AssertNoErr(t, err)
    24  
    25  	volume, err := blockstorage.CreateVolume(t, blockClient)
    26  	th.AssertNoErr(t, err)
    27  	defer blockstorage.DeleteVolume(t, blockClient, volume)
    28  
    29  	volumeImage, err := CreateUploadImage(t, blockClient, volume)
    30  	th.AssertNoErr(t, err)
    31  
    32  	tools.PrintResource(t, volumeImage)
    33  
    34  	err = DeleteUploadedImage(t, computeClient, volumeImage.ImageID)
    35  	th.AssertNoErr(t, err)
    36  }
    37  
    38  func TestVolumeActionsAttachCreateDestroy(t *testing.T) {
    39  	blockClient, err := clients.NewBlockStorageV3Client()
    40  	th.AssertNoErr(t, err)
    41  
    42  	computeClient, err := clients.NewComputeV2Client()
    43  	th.AssertNoErr(t, err)
    44  
    45  	server, err := compute.CreateServer(t, computeClient)
    46  	th.AssertNoErr(t, err)
    47  	defer compute.DeleteServer(t, computeClient, server)
    48  
    49  	volume, err := blockstorage.CreateVolume(t, blockClient)
    50  	th.AssertNoErr(t, err)
    51  	defer blockstorage.DeleteVolume(t, blockClient, volume)
    52  
    53  	err = CreateVolumeAttach(t, blockClient, volume, server)
    54  	th.AssertNoErr(t, err)
    55  
    56  	newVolume, err := volumes.Get(blockClient, volume.ID).Extract()
    57  	th.AssertNoErr(t, err)
    58  
    59  	DeleteVolumeAttach(t, blockClient, newVolume)
    60  }
    61  
    62  func TestVolumeActionsReserveUnreserve(t *testing.T) {
    63  	client, err := clients.NewBlockStorageV3Client()
    64  	th.AssertNoErr(t, err)
    65  
    66  	volume, err := blockstorage.CreateVolume(t, client)
    67  	th.AssertNoErr(t, err)
    68  	defer blockstorage.DeleteVolume(t, client, volume)
    69  
    70  	err = CreateVolumeReserve(t, client, volume)
    71  	th.AssertNoErr(t, err)
    72  	defer DeleteVolumeReserve(t, client, volume)
    73  }
    74  
    75  func TestVolumeActionsExtendSize(t *testing.T) {
    76  	blockClient, err := clients.NewBlockStorageV3Client()
    77  	th.AssertNoErr(t, err)
    78  
    79  	volume, err := blockstorage.CreateVolume(t, blockClient)
    80  	th.AssertNoErr(t, err)
    81  	defer blockstorage.DeleteVolume(t, blockClient, volume)
    82  
    83  	tools.PrintResource(t, volume)
    84  
    85  	err = ExtendVolumeSize(t, blockClient, volume)
    86  	th.AssertNoErr(t, err)
    87  
    88  	newVolume, err := volumes.Get(blockClient, volume.ID).Extract()
    89  	th.AssertNoErr(t, err)
    90  
    91  	tools.PrintResource(t, newVolume)
    92  }
    93  
    94  func TestVolumeActionsImageMetadata(t *testing.T) {
    95  	blockClient, err := clients.NewBlockStorageV3Client()
    96  	th.AssertNoErr(t, err)
    97  
    98  	volume, err := blockstorage.CreateVolume(t, blockClient)
    99  	th.AssertNoErr(t, err)
   100  	defer blockstorage.DeleteVolume(t, blockClient, volume)
   101  
   102  	err = SetImageMetadata(t, blockClient, volume)
   103  	th.AssertNoErr(t, err)
   104  }
   105  
   106  func TestVolumeActionsSetBootable(t *testing.T) {
   107  	blockClient, err := clients.NewBlockStorageV3Client()
   108  	th.AssertNoErr(t, err)
   109  
   110  	volume, err := blockstorage.CreateVolume(t, blockClient)
   111  	th.AssertNoErr(t, err)
   112  	defer blockstorage.DeleteVolume(t, blockClient, volume)
   113  
   114  	err = SetBootable(t, blockClient, volume)
   115  	th.AssertNoErr(t, err)
   116  }
   117  
   118  func TestVolumeActionsChangeType(t *testing.T) {
   119  	//	clients.RequireAdmin(t)
   120  
   121  	client, err := clients.NewBlockStorageV3Client()
   122  	th.AssertNoErr(t, err)
   123  
   124  	volumeType1, err := blockstorageV3.CreateVolumeTypeNoExtraSpecs(t, client)
   125  	th.AssertNoErr(t, err)
   126  	defer blockstorageV3.DeleteVolumeType(t, client, volumeType1)
   127  
   128  	volumeType2, err := blockstorageV3.CreateVolumeTypeNoExtraSpecs(t, client)
   129  	th.AssertNoErr(t, err)
   130  	defer blockstorageV3.DeleteVolumeType(t, client, volumeType2)
   131  
   132  	volume, err := blockstorageV3.CreateVolumeWithType(t, client, volumeType1)
   133  	th.AssertNoErr(t, err)
   134  	defer blockstorageV3.DeleteVolume(t, client, volume)
   135  
   136  	tools.PrintResource(t, volume)
   137  
   138  	err = ChangeVolumeType(t, client, volume, volumeType2)
   139  	th.AssertNoErr(t, err)
   140  
   141  	newVolume, err := volumes.Get(client, volume.ID).Extract()
   142  	th.AssertNoErr(t, err)
   143  	th.AssertEquals(t, newVolume.VolumeType, volumeType2.Name)
   144  
   145  	tools.PrintResource(t, newVolume)
   146  }
   147  
   148  func TestVolumeActionsResetStatus(t *testing.T) {
   149  	client, err := clients.NewBlockStorageV3Client()
   150  	th.AssertNoErr(t, err)
   151  
   152  	volume, err := blockstorageV3.CreateVolume(t, client)
   153  	th.AssertNoErr(t, err)
   154  	defer blockstorageV3.DeleteVolume(t, client, volume)
   155  
   156  	tools.PrintResource(t, volume)
   157  
   158  	err = ResetVolumeStatus(t, client, volume, "error")
   159  	th.AssertNoErr(t, err)
   160  
   161  	err = ResetVolumeStatus(t, client, volume, "available")
   162  	th.AssertNoErr(t, err)
   163  }
   164  
   165  func TestVolumeActionsReImage(t *testing.T) {
   166  	clients.SkipReleasesBelow(t, "stable/yoga")
   167  
   168  	choices, err := clients.AcceptanceTestChoicesFromEnv()
   169  	if err != nil {
   170  		t.Fatal(err)
   171  	}
   172  
   173  	blockClient, err := clients.NewBlockStorageV3Client()
   174  	th.AssertNoErr(t, err)
   175  	blockClient.Microversion = "3.68"
   176  
   177  	volume, err := blockstorage.CreateVolume(t, blockClient)
   178  	th.AssertNoErr(t, err)
   179  	defer blockstorage.DeleteVolume(t, blockClient, volume)
   180  
   181  	err = ReImage(t, blockClient, volume, choices.ImageID)
   182  	th.AssertNoErr(t, err)
   183  }
   184  
   185  // Note(jtopjian): I plan to work on this at some point, but it requires
   186  // setting up a server with iscsi utils.
   187  /*
   188  func TestVolumeConns(t *testing.T) {
   189      client, err := newClient()
   190      th.AssertNoErr(t, err)
   191  
   192      t.Logf("Creating volume")
   193      cv, err := volumes.Create(client, &volumes.CreateOpts{
   194          Size: 1,
   195          Name: "blockv2-volume",
   196      }).Extract()
   197      th.AssertNoErr(t, err)
   198  
   199      defer func() {
   200          err = volumes.WaitForStatus(client, cv.ID, "available", 60)
   201          th.AssertNoErr(t, err)
   202  
   203          t.Logf("Deleting volume")
   204          err = volumes.Delete(client, cv.ID, volumes.DeleteOpts{}).ExtractErr()
   205          th.AssertNoErr(t, err)
   206      }()
   207  
   208      err = volumes.WaitForStatus(client, cv.ID, "available", 60)
   209      th.AssertNoErr(t, err)
   210  
   211      connOpts := &volumeactions.ConnectorOpts{
   212          IP:        "127.0.0.1",
   213          Host:      "stack",
   214          Initiator: "iqn.1994-05.com.redhat:17cf566367d2",
   215          Multipath: false,
   216          Platform:  "x86_64",
   217          OSType:    "linux2",
   218      }
   219  
   220      t.Logf("Initializing connection")
   221      _, err = volumeactions.InitializeConnection(client, cv.ID, connOpts).Extract()
   222      th.AssertNoErr(t, err)
   223  
   224      t.Logf("Terminating connection")
   225      err = volumeactions.TerminateConnection(client, cv.ID, connOpts).ExtractErr()
   226      th.AssertNoErr(t, err)
   227  }
   228  */