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

     1  //go:build acceptance || blockstorage || volumes
     2  
     3  package v2
     4  
     5  import (
     6  	"context"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/clients"
    11  	compute "github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/openstack/compute/v2"
    12  	"github.com/vnpaycloud-console/gophercloud/v2/internal/acceptance/tools"
    13  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/blockstorage/v2/snapshots"
    14  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/blockstorage/v2/volumes"
    15  	th "github.com/vnpaycloud-console/gophercloud/v2/testhelper"
    16  )
    17  
    18  func TestVolumesCreateDestroy(t *testing.T) {
    19  	clients.SkipReleasesAbove(t, "stable/ocata")
    20  	clients.RequireLong(t)
    21  
    22  	client, err := clients.NewBlockStorageV2Client()
    23  	th.AssertNoErr(t, err)
    24  
    25  	volume, err := CreateVolume(t, client)
    26  	th.AssertNoErr(t, err)
    27  	defer DeleteVolume(t, client, volume)
    28  
    29  	newVolume, err := volumes.Get(context.TODO(), client, volume.ID).Extract()
    30  	th.AssertNoErr(t, err)
    31  
    32  	// Update volume
    33  	updatedVolumeName := ""
    34  	updatedVolumeDescription := ""
    35  	updateOpts := volumes.UpdateOpts{
    36  		Name:        &updatedVolumeName,
    37  		Description: &updatedVolumeDescription,
    38  	}
    39  	updatedVolume, err := volumes.Update(context.TODO(), client, volume.ID, updateOpts).Extract()
    40  	th.AssertNoErr(t, err)
    41  
    42  	tools.PrintResource(t, updatedVolume)
    43  	th.AssertEquals(t, updatedVolume.Name, updatedVolumeName)
    44  	th.AssertEquals(t, updatedVolume.Description, updatedVolumeDescription)
    45  
    46  	allPages, err := volumes.List(client, volumes.ListOpts{}).AllPages(context.TODO())
    47  	th.AssertNoErr(t, err)
    48  
    49  	allVolumes, err := volumes.ExtractVolumes(allPages)
    50  	th.AssertNoErr(t, err)
    51  
    52  	var found bool
    53  	for _, v := range allVolumes {
    54  		tools.PrintResource(t, volume)
    55  		if v.ID == newVolume.ID {
    56  			found = true
    57  		}
    58  	}
    59  
    60  	th.AssertEquals(t, found, true)
    61  }
    62  
    63  func TestVolumesCreateForceDestroy(t *testing.T) {
    64  	clients.SkipReleasesAbove(t, "stable/ocata")
    65  	clients.RequireLong(t)
    66  
    67  	client, err := clients.NewBlockStorageV2Client()
    68  	th.AssertNoErr(t, err)
    69  
    70  	volume, err := CreateVolume(t, client)
    71  	th.AssertNoErr(t, err)
    72  
    73  	newVolume, err := volumes.Get(context.TODO(), client, volume.ID).Extract()
    74  	th.AssertNoErr(t, err)
    75  
    76  	tools.PrintResource(t, newVolume)
    77  
    78  	err = volumes.ForceDelete(context.TODO(), client, newVolume.ID).ExtractErr()
    79  	th.AssertNoErr(t, err)
    80  }
    81  
    82  func TestVolumesCascadeDelete(t *testing.T) {
    83  	clients.SkipReleasesAbove(t, "stable/ocata")
    84  	clients.RequireLong(t)
    85  
    86  	client, err := clients.NewBlockStorageV2Client()
    87  	th.AssertNoErr(t, err)
    88  
    89  	vol, err := CreateVolume(t, client)
    90  	th.AssertNoErr(t, err)
    91  
    92  	ctx, cancel := context.WithTimeout(context.TODO(), 60*time.Second)
    93  	defer cancel()
    94  
    95  	err = volumes.WaitForStatus(ctx, client, vol.ID, "available")
    96  	th.AssertNoErr(t, err)
    97  
    98  	snapshot1, err := CreateSnapshot(t, client, vol)
    99  	th.AssertNoErr(t, err)
   100  
   101  	snapshot2, err := CreateSnapshot(t, client, vol)
   102  	th.AssertNoErr(t, err)
   103  
   104  	t.Logf("Attempting to delete volume: %s", vol.ID)
   105  
   106  	deleteOpts := volumes.DeleteOpts{Cascade: true}
   107  	err = volumes.Delete(context.TODO(), client, vol.ID, deleteOpts).ExtractErr()
   108  	if err != nil {
   109  		t.Fatalf("Unable to delete volume %s: %v", vol.ID, err)
   110  	}
   111  
   112  	for _, sid := range []string{snapshot1.ID, snapshot2.ID} {
   113  		err := tools.WaitFor(func(ctx context.Context) (bool, error) {
   114  			_, err := snapshots.Get(ctx, client, sid).Extract()
   115  			if err != nil {
   116  				return true, nil
   117  			}
   118  			return false, nil
   119  		})
   120  		th.AssertNoErr(t, err)
   121  		t.Logf("Successfully deleted snapshot: %s", sid)
   122  	}
   123  
   124  	err = tools.WaitFor(func(ctx context.Context) (bool, error) {
   125  		_, err := volumes.Get(ctx, client, vol.ID).Extract()
   126  		if err != nil {
   127  			return true, nil
   128  		}
   129  		return false, nil
   130  	})
   131  	th.AssertNoErr(t, err)
   132  
   133  	t.Logf("Successfully deleted volume: %s", vol.ID)
   134  }
   135  
   136  func TestVolumeActionsUploadImageDestroy(t *testing.T) {
   137  	clients.SkipReleasesAbove(t, "stable/ocata")
   138  
   139  	blockClient, err := clients.NewBlockStorageV2Client()
   140  	th.AssertNoErr(t, err)
   141  
   142  	imageClient, err := clients.NewImageV2Client()
   143  	th.AssertNoErr(t, err)
   144  
   145  	volume, err := CreateVolume(t, blockClient)
   146  	th.AssertNoErr(t, err)
   147  	defer DeleteVolume(t, blockClient, volume)
   148  
   149  	volumeImage, err := CreateUploadImage(t, blockClient, volume)
   150  	th.AssertNoErr(t, err)
   151  
   152  	tools.PrintResource(t, volumeImage)
   153  
   154  	err = DeleteUploadedImage(t, imageClient, volumeImage.ImageID)
   155  	th.AssertNoErr(t, err)
   156  }
   157  
   158  func TestVolumeActionsAttachCreateDestroy(t *testing.T) {
   159  	clients.SkipReleasesAbove(t, "stable/ocata")
   160  
   161  	blockClient, err := clients.NewBlockStorageV2Client()
   162  	th.AssertNoErr(t, err)
   163  
   164  	computeClient, err := clients.NewComputeV2Client()
   165  	th.AssertNoErr(t, err)
   166  
   167  	server, err := compute.CreateServer(t, computeClient)
   168  	th.AssertNoErr(t, err)
   169  	defer compute.DeleteServer(t, computeClient, server)
   170  
   171  	volume, err := CreateVolume(t, blockClient)
   172  	th.AssertNoErr(t, err)
   173  	defer DeleteVolume(t, blockClient, volume)
   174  
   175  	err = CreateVolumeAttach(t, blockClient, volume, server)
   176  	th.AssertNoErr(t, err)
   177  
   178  	newVolume, err := volumes.Get(context.TODO(), blockClient, volume.ID).Extract()
   179  	th.AssertNoErr(t, err)
   180  
   181  	DeleteVolumeAttach(t, blockClient, newVolume)
   182  }
   183  
   184  func TestVolumeActionsReserveUnreserve(t *testing.T) {
   185  	clients.SkipReleasesAbove(t, "stable/ocata")
   186  
   187  	client, err := clients.NewBlockStorageV2Client()
   188  	th.AssertNoErr(t, err)
   189  
   190  	volume, err := CreateVolume(t, client)
   191  	th.AssertNoErr(t, err)
   192  	defer DeleteVolume(t, client, volume)
   193  
   194  	err = CreateVolumeReserve(t, client, volume)
   195  	th.AssertNoErr(t, err)
   196  	defer DeleteVolumeReserve(t, client, volume)
   197  }
   198  
   199  func TestVolumeActionsExtendSize(t *testing.T) {
   200  	clients.SkipReleasesAbove(t, "stable/ocata")
   201  
   202  	blockClient, err := clients.NewBlockStorageV2Client()
   203  	th.AssertNoErr(t, err)
   204  
   205  	volume, err := CreateVolume(t, blockClient)
   206  	th.AssertNoErr(t, err)
   207  	defer DeleteVolume(t, blockClient, volume)
   208  
   209  	tools.PrintResource(t, volume)
   210  
   211  	err = ExtendVolumeSize(t, blockClient, volume)
   212  	th.AssertNoErr(t, err)
   213  
   214  	newVolume, err := volumes.Get(context.TODO(), blockClient, volume.ID).Extract()
   215  	th.AssertNoErr(t, err)
   216  
   217  	tools.PrintResource(t, newVolume)
   218  }
   219  
   220  func TestVolumeActionsImageMetadata(t *testing.T) {
   221  	clients.SkipReleasesAbove(t, "stable/ocata")
   222  
   223  	blockClient, err := clients.NewBlockStorageV2Client()
   224  	th.AssertNoErr(t, err)
   225  
   226  	volume, err := CreateVolume(t, blockClient)
   227  	th.AssertNoErr(t, err)
   228  	defer DeleteVolume(t, blockClient, volume)
   229  
   230  	err = SetImageMetadata(t, blockClient, volume)
   231  	th.AssertNoErr(t, err)
   232  }
   233  
   234  func TestVolumeActionsSetBootable(t *testing.T) {
   235  	clients.SkipReleasesAbove(t, "stable/ocata")
   236  
   237  	blockClient, err := clients.NewBlockStorageV2Client()
   238  	th.AssertNoErr(t, err)
   239  
   240  	volume, err := CreateVolume(t, blockClient)
   241  	th.AssertNoErr(t, err)
   242  	defer DeleteVolume(t, blockClient, volume)
   243  
   244  	err = SetBootable(t, blockClient, volume)
   245  	th.AssertNoErr(t, err)
   246  }
   247  
   248  func TestVolumeActionsResetStatus(t *testing.T) {
   249  	clients.SkipReleasesAbove(t, "stable/ocata")
   250  
   251  	client, err := clients.NewBlockStorageV2Client()
   252  	th.AssertNoErr(t, err)
   253  
   254  	volume, err := CreateVolume(t, client)
   255  	th.AssertNoErr(t, err)
   256  	defer DeleteVolume(t, client, volume)
   257  
   258  	tools.PrintResource(t, volume)
   259  
   260  	err = ResetVolumeStatus(t, client, volume, "error")
   261  	th.AssertNoErr(t, err)
   262  
   263  	err = ResetVolumeStatus(t, client, volume, "available")
   264  	th.AssertNoErr(t, err)
   265  }
   266  
   267  // Note(jtopjian): I plan to work on this at some point, but it requires
   268  // setting up a server with iscsi utils.
   269  /*
   270  func TestVolumeConns(t *testing.T) {
   271      clients.SkipReleasesAbove(t, "stable/ocata")
   272  
   273      client, err := newClient()
   274      th.AssertNoErr(t, err)
   275  
   276      t.Logf("Creating volume")
   277      cv, err := volumes.Create(client, &volumes.CreateOpts{
   278          Size: 1,
   279          Name: "blockv2-volume",
   280      }, nil).Extract()
   281      th.AssertNoErr(t, err)
   282  
   283      defer func() {
   284          err = volumes.WaitForStatus(client, cv.ID, "available", 60)
   285          th.AssertNoErr(t, err)
   286  
   287          t.Logf("Deleting volume")
   288          err = volumes.Delete(client, cv.ID, volumes.DeleteOpts{}).ExtractErr()
   289          th.AssertNoErr(t, err)
   290      }()
   291  
   292      err = volumes.WaitForStatus(client, cv.ID, "available", 60)
   293      th.AssertNoErr(t, err)
   294  
   295      connOpts := &volumes.ConnectorOpts{
   296          IP:        "127.0.0.1",
   297          Host:      "stack",
   298          Initiator: "iqn.1994-05.com.redhat:17cf566367d2",
   299          Multipath: false,
   300          Platform:  "x86_64",
   301          OSType:    "linux2",
   302      }
   303  
   304      t.Logf("Initializing connection")
   305      _, err = volumes.InitializeConnection(client, cv.ID, connOpts).Extract()
   306      th.AssertNoErr(t, err)
   307  
   308      t.Logf("Terminating connection")
   309      err = volumes.TerminateConnection(client, cv.ID, connOpts).ExtractErr()
   310      th.AssertNoErr(t, err)
   311  }
   312  */