github.com/leeclow-ops/gophercloud@v1.2.1/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/leeclow-ops/gophercloud/acceptance/clients"
    10  	blockstorage "github.com/leeclow-ops/gophercloud/acceptance/openstack/blockstorage/v2"
    11  	blockstorageV3 "github.com/leeclow-ops/gophercloud/acceptance/openstack/blockstorage/v3"
    12  	compute "github.com/leeclow-ops/gophercloud/acceptance/openstack/compute/v2"
    13  	"github.com/leeclow-ops/gophercloud/acceptance/tools"
    14  	"github.com/leeclow-ops/gophercloud/openstack/blockstorage/v2/volumes"
    15  	th "github.com/leeclow-ops/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 TestVolumeActionsReImage(t *testing.T) {
   149  	clients.SkipReleasesBelow(t, "stable/yoga")
   150  
   151  	choices, err := clients.AcceptanceTestChoicesFromEnv()
   152  	if err != nil {
   153  		t.Fatal(err)
   154  	}
   155  
   156  	blockClient, err := clients.NewBlockStorageV3Client()
   157  	th.AssertNoErr(t, err)
   158  	blockClient.Microversion = "3.68"
   159  
   160  	volume, err := blockstorage.CreateVolume(t, blockClient)
   161  	th.AssertNoErr(t, err)
   162  	defer blockstorage.DeleteVolume(t, blockClient, volume)
   163  
   164  	err = ReImage(t, blockClient, volume, choices.ImageID)
   165  	th.AssertNoErr(t, err)
   166  }
   167  
   168  // Note(jtopjian): I plan to work on this at some point, but it requires
   169  // setting up a server with iscsi utils.
   170  /*
   171  func TestVolumeConns(t *testing.T) {
   172      client, err := newClient()
   173      th.AssertNoErr(t, err)
   174  
   175      t.Logf("Creating volume")
   176      cv, err := volumes.Create(client, &volumes.CreateOpts{
   177          Size: 1,
   178          Name: "blockv2-volume",
   179      }).Extract()
   180      th.AssertNoErr(t, err)
   181  
   182      defer func() {
   183          err = volumes.WaitForStatus(client, cv.ID, "available", 60)
   184          th.AssertNoErr(t, err)
   185  
   186          t.Logf("Deleting volume")
   187          err = volumes.Delete(client, cv.ID, volumes.DeleteOpts{}).ExtractErr()
   188          th.AssertNoErr(t, err)
   189      }()
   190  
   191      err = volumes.WaitForStatus(client, cv.ID, "available", 60)
   192      th.AssertNoErr(t, err)
   193  
   194      connOpts := &volumeactions.ConnectorOpts{
   195          IP:        "127.0.0.1",
   196          Host:      "stack",
   197          Initiator: "iqn.1994-05.com.redhat:17cf566367d2",
   198          Multipath: false,
   199          Platform:  "x86_64",
   200          OSType:    "linux2",
   201      }
   202  
   203      t.Logf("Initializing connection")
   204      _, err = volumeactions.InitializeConnection(client, cv.ID, connOpts).Extract()
   205      th.AssertNoErr(t, err)
   206  
   207      t.Logf("Terminating connection")
   208      err = volumeactions.TerminateConnection(client, cv.ID, connOpts).ExtractErr()
   209      th.AssertNoErr(t, err)
   210  }
   211  */