github.com/vmware/go-vcloud-director/v2@v2.24.0/govcd/disk_test.go (about)

     1  //go:build disk || functional || ALL
     2  
     3  /*
     4   * Copyright 2019 VMware, Inc.  All rights reserved.  Licensed under the Apache v2 License.
     5   */
     6  
     7  package govcd
     8  
     9  import (
    10  	"fmt"
    11  	"strings"
    12  
    13  	. "gopkg.in/check.v1"
    14  
    15  	"github.com/vmware/go-vcloud-director/v2/types/v56"
    16  )
    17  
    18  // Test init independent disk struct
    19  func (vcd *TestVCD) Test_NewDisk(check *C) {
    20  	fmt.Printf("Running: %s\n", check.TestName())
    21  
    22  	disk := NewDisk(&vcd.client.Client)
    23  	check.Assert(disk, NotNil)
    24  }
    25  
    26  // Test create independent disk
    27  func (vcd *TestVCD) Test_CreateDisk(check *C) {
    28  	fmt.Printf("Running: %s\n", check.TestName())
    29  
    30  	// Create disk
    31  	diskCreateParamsDisk := &types.Disk{
    32  		Name:        TestCreateDisk,
    33  		SizeMb:      11,
    34  		Description: TestCreateDisk,
    35  	}
    36  
    37  	diskCreateParams := &types.DiskCreateParams{
    38  		Disk: diskCreateParamsDisk,
    39  	}
    40  
    41  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
    42  	check.Assert(err, IsNil)
    43  
    44  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
    45  	diskHREF := task.Task.Owner.HREF
    46  
    47  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
    48  
    49  	// Wait for disk creation complete
    50  	err = task.WaitTaskCompletion()
    51  	check.Assert(err, IsNil)
    52  
    53  	// Verify created disk
    54  	check.Assert(diskHREF, Not(Equals), "")
    55  	disk, err := vcd.vdc.GetDiskByHref(diskHREF)
    56  	check.Assert(err, IsNil)
    57  	check.Assert(disk.Disk.Name, Equals, diskCreateParamsDisk.Name)
    58  	check.Assert(disk.Disk.SizeMb, Equals, diskCreateParamsDisk.SizeMb)
    59  	check.Assert(disk.Disk.Description, Equals, diskCreateParamsDisk.Description)
    60  	if vcd.client.Client.APIVCDMaxVersionIs(">= 36") {
    61  		check.Assert(disk.Disk.UUID, Not(Equals), "")
    62  		check.Assert(disk.Disk.SharingType, Equals, "None")
    63  		check.Assert(disk.Disk.Encrypted, Equals, false)
    64  	}
    65  
    66  }
    67  
    68  // Test update independent disk
    69  func (vcd *TestVCD) Test_UpdateDisk(check *C) {
    70  	fmt.Printf("Running: %s\n", check.TestName())
    71  
    72  	// Create disk
    73  	diskCreateParamsDisk := &types.Disk{
    74  		Name:        TestUpdateDisk,
    75  		SizeMb:      99,
    76  		Description: TestUpdateDisk,
    77  	}
    78  
    79  	diskCreateParams := &types.DiskCreateParams{
    80  		Disk: diskCreateParamsDisk,
    81  	}
    82  
    83  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
    84  	check.Assert(err, IsNil)
    85  
    86  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
    87  	diskHREF := task.Task.Owner.HREF
    88  
    89  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
    90  
    91  	// Wait for disk creation complete
    92  	err = task.WaitTaskCompletion()
    93  	check.Assert(err, IsNil)
    94  
    95  	// Verify created disk
    96  	check.Assert(diskHREF, Not(Equals), "")
    97  	disk, err := vcd.vdc.GetDiskByHref(diskHREF)
    98  	check.Assert(err, IsNil)
    99  	check.Assert(disk.Disk.Name, Equals, diskCreateParamsDisk.Name)
   100  	check.Assert(disk.Disk.SizeMb, Equals, diskCreateParamsDisk.SizeMb)
   101  	check.Assert(disk.Disk.Description, Equals, diskCreateParamsDisk.Description)
   102  
   103  	// Update disk
   104  	newDiskInfo := &types.Disk{
   105  		Name:        TestUpdateDisk,
   106  		SizeMb:      102,
   107  		Description: TestUpdateDisk + "_Update",
   108  	}
   109  
   110  	updateTask, err := disk.Update(newDiskInfo)
   111  	check.Assert(err, IsNil)
   112  	err = updateTask.WaitTaskCompletion()
   113  	check.Assert(err, IsNil)
   114  
   115  	// Refresh disk info, getting updated info
   116  	err = disk.Refresh()
   117  	check.Assert(err, IsNil)
   118  	check.Assert(disk.Disk.Name, Equals, newDiskInfo.Name)
   119  	check.Assert(disk.Disk.SizeMb, Equals, newDiskInfo.SizeMb)
   120  	check.Assert(disk.Disk.Description, Equals, newDiskInfo.Description)
   121  
   122  }
   123  
   124  // Test delete independent disk
   125  func (vcd *TestVCD) Test_DeleteDisk(check *C) {
   126  	fmt.Printf("Running: %s\n", check.TestName())
   127  
   128  	var err error
   129  
   130  	// Create disk
   131  	diskCreateParamsDisk := &types.Disk{
   132  		Name:        TestDeleteDisk,
   133  		SizeMb:      1,
   134  		Description: TestDeleteDisk,
   135  	}
   136  
   137  	diskCreateParams := &types.DiskCreateParams{
   138  		Disk: diskCreateParamsDisk,
   139  	}
   140  
   141  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   142  	check.Assert(err, IsNil)
   143  
   144  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   145  	diskHREF := task.Task.Owner.HREF
   146  
   147  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   148  
   149  	// Wait for disk creation complete
   150  	err = task.WaitTaskCompletion()
   151  	check.Assert(err, IsNil)
   152  
   153  	// Verify created disk
   154  	check.Assert(diskHREF, Not(Equals), "")
   155  	disk, err := vcd.vdc.GetDiskByHref(diskHREF)
   156  	check.Assert(err, IsNil)
   157  	check.Assert(disk.Disk.Name, Equals, diskCreateParamsDisk.Name)
   158  	check.Assert(disk.Disk.SizeMb, Equals, diskCreateParamsDisk.SizeMb)
   159  	check.Assert(disk.Disk.Description, Equals, diskCreateParamsDisk.Description)
   160  
   161  	// Delete disk
   162  	deleteDiskTask, err := disk.Delete()
   163  	check.Assert(err, IsNil)
   164  
   165  	err = deleteDiskTask.WaitTaskCompletion()
   166  	check.Assert(err, IsNil)
   167  }
   168  
   169  // Test refresh independent disk info
   170  func (vcd *TestVCD) Test_RefreshDisk(check *C) {
   171  	fmt.Printf("Running: %s\n", check.TestName())
   172  
   173  	// Create disk
   174  	diskCreateParamsDisk := &types.Disk{
   175  		Name:        TestRefreshDisk,
   176  		SizeMb:      43,
   177  		Description: TestRefreshDisk,
   178  	}
   179  
   180  	diskCreateParams := &types.DiskCreateParams{
   181  		Disk: diskCreateParamsDisk,
   182  	}
   183  
   184  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   185  	check.Assert(err, IsNil)
   186  
   187  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   188  	diskHREF := task.Task.Owner.HREF
   189  
   190  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   191  
   192  	// Wait for disk creation complete
   193  	err = task.WaitTaskCompletion()
   194  	check.Assert(err, IsNil)
   195  
   196  	// Verify created disk
   197  	check.Assert(diskHREF, Not(Equals), "")
   198  	disk, err := vcd.vdc.GetDiskByHref(diskHREF)
   199  	check.Assert(err, IsNil)
   200  	check.Assert(disk.Disk.Name, Equals, diskCreateParamsDisk.Name)
   201  	check.Assert(disk.Disk.SizeMb, Equals, diskCreateParamsDisk.SizeMb)
   202  	check.Assert(disk.Disk.Description, Equals, diskCreateParamsDisk.Description)
   203  
   204  	// Update disk
   205  	newDiskInfo := &types.Disk{
   206  		Name:        TestRefreshDisk,
   207  		SizeMb:      43,
   208  		Description: TestRefreshDisk + "_Update",
   209  	}
   210  
   211  	updateTask, err := disk.Update(newDiskInfo)
   212  	check.Assert(err, IsNil)
   213  	err = updateTask.WaitTaskCompletion()
   214  	check.Assert(err, IsNil)
   215  
   216  	// Refresh disk info, getting updated info
   217  	err = disk.Refresh()
   218  	check.Assert(err, IsNil)
   219  	check.Assert(disk.Disk.Name, Equals, newDiskInfo.Name)
   220  	check.Assert(disk.Disk.SizeMb, Equals, newDiskInfo.SizeMb)
   221  	check.Assert(disk.Disk.Description, Equals, newDiskInfo.Description)
   222  
   223  }
   224  
   225  // Test find disk attached VM
   226  func (vcd *TestVCD) Test_AttachedVMDisk(check *C) {
   227  	if vcd.skipVappTests {
   228  		check.Skip("skipping test because vApp wasn't properly created")
   229  	}
   230  
   231  	// Find VM
   232  	vapp := vcd.findFirstVapp()
   233  	vmType, vmName := vcd.findFirstVm(vapp)
   234  	if vmName == "" {
   235  		check.Skip("skipping test because no VM is found")
   236  	}
   237  
   238  	fmt.Printf("Running: %s\n", check.TestName())
   239  
   240  	vm := NewVM(&vcd.client.Client)
   241  	vm.VM = &vmType
   242  
   243  	// Ensure vApp and VM are suitable for this test
   244  	// Disk attach and detach operations are not working if VM is suspended
   245  	err := vcd.ensureVappIsSuitableForVMTest(vapp)
   246  	check.Assert(err, IsNil)
   247  	err = vcd.ensureVMIsSuitableForVMTest(vm)
   248  	check.Assert(err, IsNil)
   249  
   250  	// Create disk
   251  	diskCreateParamsDisk := &types.Disk{
   252  		Name:        TestAttachedVMDisk,
   253  		SizeMb:      210,
   254  		Description: TestAttachedVMDisk,
   255  	}
   256  
   257  	diskCreateParams := &types.DiskCreateParams{
   258  		Disk: diskCreateParamsDisk,
   259  	}
   260  
   261  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   262  	check.Assert(err, IsNil)
   263  
   264  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   265  	diskHREF := task.Task.Owner.HREF
   266  
   267  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   268  
   269  	// Wait for disk creation complete
   270  	err = task.WaitTaskCompletion()
   271  	check.Assert(err, IsNil)
   272  
   273  	// Verify created disk
   274  	check.Assert(diskHREF, Not(Equals), "")
   275  	disk, err := vcd.vdc.GetDiskByHref(diskHREF)
   276  	check.Assert(err, IsNil)
   277  	check.Assert(disk.Disk.Name, Equals, diskCreateParamsDisk.Name)
   278  	check.Assert(disk.Disk.SizeMb, Equals, diskCreateParamsDisk.SizeMb)
   279  	check.Assert(disk.Disk.Description, Equals, diskCreateParamsDisk.Description)
   280  
   281  	// Attach disk
   282  	attachDiskTask, err := vm.AttachDisk(&types.DiskAttachOrDetachParams{
   283  		Disk: &types.Reference{
   284  			HREF: disk.Disk.HREF,
   285  		},
   286  	})
   287  	check.Assert(err, IsNil)
   288  
   289  	err = attachDiskTask.WaitTaskCompletion()
   290  	check.Assert(err, IsNil)
   291  
   292  	// Get attached VM
   293  	vmRef, err := disk.AttachedVM()
   294  	check.Assert(err, IsNil)
   295  	check.Assert(vmRef, NotNil)
   296  	check.Assert(vmRef.Name, Equals, vm.VM.Name)
   297  
   298  	// Get attached VM
   299  	vmHrefs, err := disk.GetAttachedVmsHrefs()
   300  	check.Assert(err, IsNil)
   301  	check.Assert(vmHrefs, NotNil)
   302  	check.Assert(len(vmHrefs), Equals, 1)
   303  	check.Assert(vmHrefs[0], Equals, vm.VM.HREF)
   304  
   305  	// Detach disk
   306  	err = vcd.detachIndependentDisk(Disk{disk.Disk, &vcd.client.Client})
   307  	check.Assert(err, IsNil)
   308  }
   309  
   310  // Test find Disk by Href in VDC struct
   311  func (vcd *TestVCD) Test_VdcFindDiskByHREF(check *C) {
   312  	fmt.Printf("Running: %s\n", check.TestName())
   313  
   314  	// Create disk
   315  	diskCreateParamsDisk := &types.Disk{
   316  		Name:        TestVdcFindDiskByHREF,
   317  		SizeMb:      2,
   318  		Description: TestVdcFindDiskByHREF,
   319  	}
   320  
   321  	diskCreateParams := &types.DiskCreateParams{
   322  		Disk: diskCreateParamsDisk,
   323  	}
   324  
   325  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   326  	check.Assert(err, IsNil)
   327  
   328  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   329  	diskHREF := task.Task.Owner.HREF
   330  
   331  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   332  
   333  	// Wait for disk creation complete
   334  	err = task.WaitTaskCompletion()
   335  	check.Assert(err, IsNil)
   336  
   337  	// Verify created disk
   338  	check.Assert(diskHREF, Not(Equals), "")
   339  	disk, err := vcd.vdc.FindDiskByHREF(diskHREF)
   340  
   341  	check.Assert(err, IsNil)
   342  	check.Assert(disk.Disk.Name, Equals, diskCreateParamsDisk.Name)
   343  	check.Assert(disk.Disk.SizeMb, Equals, diskCreateParamsDisk.SizeMb)
   344  	check.Assert(disk.Disk.Description, Equals, diskCreateParamsDisk.Description)
   345  
   346  }
   347  
   348  // Test find disk by href and vdc client
   349  func (vcd *TestVCD) Test_FindDiskByHREF(check *C) {
   350  	fmt.Printf("Running: %s\n", check.TestName())
   351  
   352  	// Create disk
   353  	diskCreateParamsDisk := &types.Disk{
   354  		Name:        TestFindDiskByHREF,
   355  		SizeMb:      3,
   356  		Description: TestFindDiskByHREF,
   357  	}
   358  
   359  	diskCreateParams := &types.DiskCreateParams{
   360  		Disk: diskCreateParamsDisk,
   361  	}
   362  
   363  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   364  	check.Assert(err, IsNil)
   365  
   366  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   367  	diskHREF := task.Task.Owner.HREF
   368  
   369  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   370  
   371  	// Wait for disk creation complete
   372  	err = task.WaitTaskCompletion()
   373  	check.Assert(err, IsNil)
   374  
   375  	// Verify created disk
   376  	check.Assert(diskHREF, Not(Equals), "")
   377  	disk, err := vcd.vdc.FindDiskByHREF(diskHREF)
   378  
   379  	check.Assert(err, IsNil)
   380  	check.Assert(disk.Disk.Name, Equals, diskCreateParamsDisk.Name)
   381  	check.Assert(disk.Disk.SizeMb, Equals, diskCreateParamsDisk.SizeMb)
   382  	check.Assert(disk.Disk.Description, Equals, diskCreateParamsDisk.Description)
   383  
   384  	// Find disk by href
   385  	foundDisk, err := FindDiskByHREF(vcd.vdc.client, disk.Disk.HREF)
   386  	check.Assert(err, IsNil)
   387  	check.Assert(disk.Disk, NotNil)
   388  	check.Assert(disk.Disk.Name, Equals, foundDisk.Disk.Name)
   389  
   390  }
   391  
   392  // Independent disk integration test
   393  func (vcd *TestVCD) Test_Disk(check *C) {
   394  	if vcd.skipVappTests {
   395  		check.Skip("skipping test because vApp wasn't properly created")
   396  	}
   397  
   398  	// Find VM
   399  	vapp := vcd.findFirstVapp()
   400  	vmType, vmName := vcd.findFirstVm(vapp)
   401  	if vmName == "" {
   402  		check.Skip("skipping test because no VM is found")
   403  	}
   404  
   405  	fmt.Printf("Running: %s\n", check.TestName())
   406  
   407  	vm := NewVM(&vcd.client.Client)
   408  	vm.VM = &vmType
   409  
   410  	// Ensure vApp and VM are suitable for this test
   411  	// Disk attach and detach operations are not working if VM is suspended
   412  	err := vcd.ensureVappIsSuitableForVMTest(vapp)
   413  	check.Assert(err, IsNil)
   414  	err = vcd.ensureVMIsSuitableForVMTest(vm)
   415  	check.Assert(err, IsNil)
   416  
   417  	// Create disk
   418  	diskCreateParamsDisk := &types.Disk{
   419  		Name:        TestDisk,
   420  		SizeMb:      14,
   421  		Description: TestDisk,
   422  	}
   423  
   424  	diskCreateParams := &types.DiskCreateParams{
   425  		Disk: diskCreateParamsDisk,
   426  	}
   427  
   428  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   429  	check.Assert(err, IsNil)
   430  
   431  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   432  	diskHREF := task.Task.Owner.HREF
   433  
   434  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   435  
   436  	// Wait for disk creation complete
   437  	err = task.WaitTaskCompletion()
   438  	check.Assert(err, IsNil)
   439  
   440  	// Verify created disk
   441  	check.Assert(diskHREF, Not(Equals), "")
   442  	disk, err := vcd.vdc.GetDiskByHref(diskHREF)
   443  	check.Assert(err, IsNil)
   444  	check.Assert(disk.Disk.Name, Equals, diskCreateParamsDisk.Name)
   445  	check.Assert(disk.Disk.SizeMb, Equals, diskCreateParamsDisk.SizeMb)
   446  	check.Assert(disk.Disk.Description, Equals, diskCreateParamsDisk.Description)
   447  
   448  	// Attach disk
   449  	attachDiskTask, err := vm.AttachDisk(&types.DiskAttachOrDetachParams{
   450  		Disk: &types.Reference{
   451  			HREF: disk.Disk.HREF,
   452  		},
   453  	})
   454  	check.Assert(err, IsNil)
   455  
   456  	err = attachDiskTask.WaitTaskCompletion()
   457  	check.Assert(err, IsNil)
   458  
   459  	// Get attached VM
   460  	vmRef, err := disk.AttachedVM()
   461  	check.Assert(err, IsNil)
   462  	check.Assert(vmRef, NotNil)
   463  	check.Assert(vmRef.Name, Equals, vm.VM.Name)
   464  
   465  	// Detach disk
   466  	detachDiskTask, err := vm.DetachDisk(&types.DiskAttachOrDetachParams{
   467  		Disk: &types.Reference{
   468  			HREF: disk.Disk.HREF,
   469  		},
   470  	})
   471  	check.Assert(err, IsNil)
   472  
   473  	err = detachDiskTask.WaitTaskCompletion()
   474  	check.Assert(err, IsNil)
   475  
   476  	// Update disk
   477  	newDiskInfo := &types.Disk{
   478  		Name:        TestDisk,
   479  		SizeMb:      41,
   480  		Description: TestDisk + "_Update",
   481  	}
   482  
   483  	updateTask, err := disk.Update(newDiskInfo)
   484  	check.Assert(err, IsNil)
   485  
   486  	err = updateTask.WaitTaskCompletion()
   487  	check.Assert(err, IsNil)
   488  
   489  	// Refresh disk Info
   490  	err = disk.Refresh()
   491  	check.Assert(err, IsNil)
   492  	check.Assert(disk.Disk.Name, Equals, newDiskInfo.Name)
   493  	check.Assert(disk.Disk.Description, Equals, newDiskInfo.Description)
   494  
   495  }
   496  
   497  // Test query disk
   498  func (vcd *TestVCD) Test_QueryDisk(check *C) {
   499  	fmt.Printf("Running: %s\n", check.TestName())
   500  
   501  	name := "TestQueryDisk"
   502  
   503  	// Create disk
   504  	diskCreateParamsDisk := &types.Disk{
   505  		Name:        name,
   506  		SizeMb:      1,
   507  		Description: name,
   508  	}
   509  
   510  	diskCreateParams := &types.DiskCreateParams{
   511  		Disk: diskCreateParamsDisk,
   512  	}
   513  
   514  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   515  	check.Assert(err, IsNil)
   516  
   517  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   518  	diskHREF := task.Task.Owner.HREF
   519  
   520  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   521  
   522  	// Wait for disk creation complete
   523  	err = task.WaitTaskCompletion()
   524  	check.Assert(err, IsNil)
   525  
   526  	// Verify created disk
   527  	check.Assert(diskHREF, Not(Equals), "")
   528  	diskRecord, err := vcd.vdc.QueryDisk(name)
   529  
   530  	check.Assert(err, IsNil)
   531  	check.Assert(diskRecord.Disk.Name, Equals, diskCreateParamsDisk.Name)
   532  	check.Assert(diskRecord.Disk.SizeMb, Equals, int64(diskCreateParamsDisk.SizeMb))
   533  	check.Assert(diskRecord.Disk.Description, Equals, diskCreateParamsDisk.Description)
   534  }
   535  
   536  // Test query disk
   537  func (vcd *TestVCD) Test_QueryDisks(check *C) {
   538  	fmt.Printf("Running: %s\n", check.TestName())
   539  
   540  	name := "TestQueryDisks"
   541  
   542  	// Create disk
   543  	diskCreateParamsDisk := &types.Disk{
   544  		Name:        name,
   545  		SizeMb:      22,
   546  		Description: name,
   547  	}
   548  
   549  	diskCreateParams := &types.DiskCreateParams{
   550  		Disk: diskCreateParamsDisk,
   551  	}
   552  
   553  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   554  	check.Assert(err, IsNil)
   555  
   556  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   557  	diskHREF := task.Task.Owner.HREF
   558  
   559  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   560  
   561  	// Wait for disk creation complete
   562  	err = task.WaitTaskCompletion()
   563  	check.Assert(err, IsNil)
   564  
   565  	// create second disk with same name
   566  	task, err = vcd.vdc.CreateDisk(diskCreateParams)
   567  	check.Assert(err, IsNil)
   568  
   569  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   570  	diskHREF = task.Task.Owner.HREF
   571  
   572  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   573  
   574  	// Wait for disk creation complete
   575  	err = task.WaitTaskCompletion()
   576  	check.Assert(err, IsNil)
   577  
   578  	// Verify created disk
   579  	check.Assert(diskHREF, Not(Equals), "")
   580  	diskRecords, err := vcd.vdc.QueryDisks(name)
   581  
   582  	check.Assert(err, IsNil)
   583  	check.Assert(len(*diskRecords), Equals, 2)
   584  	check.Assert((*diskRecords)[0].Name, Equals, diskCreateParamsDisk.Name)
   585  	check.Assert((*diskRecords)[0].SizeMb, Equals, int64(diskCreateParamsDisk.SizeMb))
   586  	if vcd.client.Client.APIVCDMaxVersionIs(">= 36") {
   587  		check.Assert((*diskRecords)[0].UUID, Not(Equals), "")
   588  		check.Assert((*diskRecords)[0].SharingType, Equals, "None")
   589  		check.Assert((*diskRecords)[0].Encrypted, Equals, false)
   590  	}
   591  }
   592  
   593  // Tests Disk list retrieval by name, by ID
   594  func (vcd *TestVCD) Test_GetDisks(check *C) {
   595  	fmt.Printf("Running: %s\n", check.TestName())
   596  	if vcd.config.VCD.Vdc == "" {
   597  		check.Skip("Test_GetDisk: VDC name not given")
   598  		return
   599  	}
   600  
   601  	diskName := "TestGetDisk"
   602  	// Create disk
   603  	diskCreateParamsDisk := &types.Disk{
   604  		Name:        diskName,
   605  		SizeMb:      12,
   606  		Description: diskName + "Description",
   607  	}
   608  
   609  	diskCreateParams := &types.DiskCreateParams{
   610  		Disk: diskCreateParamsDisk,
   611  	}
   612  
   613  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   614  	check.Assert(err, IsNil)
   615  
   616  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   617  	diskHREF := task.Task.Owner.HREF
   618  
   619  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   620  
   621  	// Wait for disk creation complete
   622  	err = task.WaitTaskCompletion()
   623  	check.Assert(err, IsNil)
   624  
   625  	err = vcd.vdc.Refresh()
   626  	check.Assert(err, IsNil)
   627  	diskList, err := vcd.vdc.GetDisksByName(diskName, false)
   628  	check.Assert(err, IsNil)
   629  	check.Assert(diskList, NotNil)
   630  	check.Assert(len(*diskList), Equals, 1)
   631  	check.Assert((*diskList)[0].Disk.Name, Equals, diskName)
   632  	check.Assert((*diskList)[0].Disk.Description, Equals, diskName+"Description")
   633  
   634  	disk, err := vcd.vdc.GetDiskById((*diskList)[0].Disk.Id, false)
   635  	check.Assert(err, IsNil)
   636  	check.Assert(disk, NotNil)
   637  	check.Assert(disk.Disk.Name, Equals, diskName)
   638  	check.Assert(disk.Disk.Description, Equals, diskName+"Description")
   639  
   640  	diskList, err = vcd.vdc.GetDisksByName("INVALID", false)
   641  	check.Assert(err, NotNil)
   642  	check.Assert(IsNotFound(err), Equals, true)
   643  	check.Assert(diskList, IsNil)
   644  
   645  	// test two disk with same name
   646  	task, err = vcd.vdc.CreateDisk(diskCreateParams)
   647  	check.Assert(err, IsNil)
   648  
   649  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   650  	diskHREF = task.Task.Owner.HREF
   651  
   652  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   653  
   654  	// Wait for disk creation complete
   655  	err = task.WaitTaskCompletion()
   656  	check.Assert(err, IsNil)
   657  
   658  	err = vcd.vdc.Refresh()
   659  	check.Assert(err, IsNil)
   660  	diskList, err = vcd.vdc.GetDisksByName(diskName, false)
   661  	check.Assert(err, IsNil)
   662  	check.Assert(diskList, NotNil)
   663  	check.Assert(len(*diskList), Equals, 2)
   664  
   665  }
   666  
   667  // Tests Disk list retrieval by name, by ID
   668  func (vcd *TestVCD) Test_GetDiskByHref(check *C) {
   669  	fmt.Printf("Running: %s\n", check.TestName())
   670  
   671  	if vcd.config.VCD.Vdc == "" {
   672  		check.Skip("Test_GetDisk: VDC name not given")
   673  		return
   674  	}
   675  
   676  	diskName := "TestGetDiskByHref"
   677  	// Create disk
   678  	diskCreateParamsDisk := &types.Disk{
   679  		Name:        diskName,
   680  		SizeMb:      2048,
   681  		Description: diskName + "Description",
   682  	}
   683  
   684  	diskCreateParams := &types.DiskCreateParams{
   685  		Disk: diskCreateParamsDisk,
   686  	}
   687  
   688  	task, err := vcd.vdc.CreateDisk(diskCreateParams)
   689  	check.Assert(err, IsNil)
   690  
   691  	check.Assert(task.Task.Owner.Type, Equals, types.MimeDisk)
   692  	diskHREF := task.Task.Owner.HREF
   693  
   694  	PrependToCleanupList(diskHREF, "disk", "", check.TestName())
   695  
   696  	// Wait for disk creation complete
   697  	err = task.WaitTaskCompletion()
   698  	check.Assert(err, IsNil)
   699  
   700  	disk, err := vcd.vdc.GetDiskByHref(diskHREF)
   701  	check.Assert(err, IsNil)
   702  	check.Assert(disk, NotNil)
   703  	check.Assert(disk.Disk.Name, Equals, diskName)
   704  	check.Assert(disk.Disk.Description, Equals, diskName+"Description")
   705  
   706  	// Creating HREF with fake UUID
   707  	uuid, err := GetUuidFromHref(diskHREF, true)
   708  	check.Assert(err, IsNil)
   709  	invalidDiskHREF := strings.ReplaceAll(diskHREF, uuid, "1abcbdb3-1111-1111-a1c2-85d261e22fcf")
   710  	disk, err = vcd.vdc.GetDiskByHref(invalidDiskHREF)
   711  	check.Assert(err, NotNil)
   712  	if vcd.client.Client.IsSysAdmin {
   713  		check.Assert(IsNotFound(err), Equals, true)
   714  	} else {
   715  		// The errors returned for non-existing disk are different for system administrator and org user
   716  		check.Assert(strings.Contains(err.Error(), "API Error: 403:"), Equals, true)
   717  	}
   718  	check.Assert(disk, IsNil)
   719  }