def _extract_volume_and_verify(self, volume_id, error_msg):
extract_result = Volume.extract(self.apiClient, volume_id,
self.zone.id, TestData.download_mode)
result = self._get_volume_store_ref_row(volume_id)
self.assertEqual(len(result), 1, TestUploadDownload.assertText)
install_path = self._get_install_path(
result[0][TestData.install_path_index])
self._verify_uploaded_volume_present(install_path, False)
url_response = urllib2.urlopen(extract_result.url)
if url_response.code != 200:
raise Exception(error_msg)
self._wait_for_removal_of_extracted_volume(volume_id,
extract_result.url)
def _extract_volume_and_verify(self, volume_id, error_msg):
extract_result = Volume.extract(self.apiClient, volume_id, self.zone.id, TestData.download_mode)
result = self._get_volume_store_ref_row(volume_id)
self.assertEqual(
len(result),
1,
TestUploadDownload.assertText
)
install_path = self._get_install_path(result[0][TestData.install_path_index])
self._verify_uploaded_volume_present(install_path, False)
url_response = urllib2.urlopen(extract_result.url)
if url_response.code != 200:
raise Exception(error_msg)
self._wait_for_removal_of_extracted_volume(volume_id, extract_result.url)
def test_01_positive_test_1(self):
"""
positive test for volume life cycle
# 1. Deploy a vm [vm1] with shared storage and data disk
# 2. Deploy a vm [vm2]with shared storage without data disk
# 3.
# 4. Create a new volume and attache to vm2
# 5. Detach data disk from vm1 and download it
# Variance(1-9)
# 6. Upload volume by providing url of downloaded volume in step 5
# 7. Attach the volume to a different vm - vm2
# 8. Try to delete an attached volume
# 9. Create template from root volume of VM1
# 10. Create new VM using the template created in step 9
# 11. Delete the template
# 12. Detach the disk from VM2 and re-attach the disk to VM1
# 13.
# 14.
# 15.Migrate volume(detached) and then attach to a vm and live-migrate
# 16.Upload volume of size smaller than storage.max.volume.upload.size(leaving the negative case)
# 17.NA
# 18.
# 19.NA
# 20.Detach data disks from VM2 and delete volume
"""
# 1. Deploy a vm [vm1] with shared storage and data disk
self.virtual_machine_1 = VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
diskofferingid=self.disk_offering_1.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_1.id)
# List data volume for vm1
list_volume = Volume.list(self.userapiclient,
virtualmachineid=self.virtual_machine_1.id,
type='DATADISK'
)
self.assertEqual(validateList(list_volume)[0], PASS, "Check List volume response for vm id %s" % self.virtual_machine_1.id)
list_data_volume_for_vm1 = list_volume[0]
self.assertEqual(len(list_volume), 1, "There is no data disk attached to vm id:%s" % self.virtual_machine_1.id)
self.assertEqual(list_data_volume_for_vm1.virtualmachineid, str(self.virtual_machine_1.id), "Check if volume state (attached) is reflected")
# 2. Deploy a vm [vm2]with shared storage without data disk
self.virtual_machine_2 = VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_2.id)
#4. Create a new volume and attache to vm2
self.volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_1.id,
zoneid=self.zone.id
)
list_data_volume = Volume.list(self.userapiclient,
id=self.volume.id
)
self.assertEqual(validateList(list_data_volume)[0], PASS, "Check List volume response for volume %s" % self.volume.id)
self.assertEqual(list_data_volume[0].id, self.volume.id, "check list volume response for volume id: %s" % self.volume.id)
self.debug("volume id %s got created successfully" % list_data_volume[0].id)
# Attach volume to vm2
self.virtual_machine_2.attach_volume(self.userapiclient,
self.volume
)
verify_attach_volume(self, self.virtual_machine_2.id, self.volume.id)
#Variance
if self.zone.localstorageenabled:
# V1.Create vm3 with local storage offering
self.virtual_machine_local_3=VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_2.id,
zoneid=self.zone.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_local_3.id)
# V2.create two data disk on local storage
self.local_volumes = []
for i in range(2):
local_volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_local.id,
zoneid=self.zone.id
)
list_local_data_volume = Volume.list(self.userapiclient,
id=local_volume.id
)
self.assertEqual(validateList(list_local_data_volume)[0], PASS, "Check List volume response for volume %s" % local_volume.id)
self.assertEqual(list_local_data_volume[0].id, local_volume.id, "check list volume response for volume id: %s" % local_volume.id)
self.debug("volume id %s got created successfully" % list_local_data_volume[0].id)
self.local_volumes.append(local_volume)
# V3.Attach local disk to vm1
self.virtual_machine_1.attach_volume(self.userapiclient,
self.local_volumes[0]
)
verify_attach_volume(self, self.virtual_machine_1.id, self.local_volumes[0].id)
if self.list_storage:
# V4.create vm4 with zone wide storage
self.virtual_machine_zone_4 = VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.tagged_so.id,
zoneid=self.zone.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_zone_4.id)
# V5.Create two data disk on zone wide storage
self.zone_volumes = []
for i in range(2):
zone_volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_tagged.id,
zoneid=self.zone.id
)
list_zone_data_volume = Volume.list(self.userapiclient,
id=zone_volume.id
)
self.assertEqual(validateList(list_zone_data_volume)[0], PASS, "Check List volume response for volume %s" % zone_volume.id)
self.assertEqual(list_zone_data_volume[0].id, zone_volume.id, "check list volume response for volume id: %s" % zone_volume.id)
self.debug("volume id:%s got created successfully" % list_zone_data_volume[0].id)
self.zone_volumes.append(zone_volume)
# V6.Attach data disk running on ZWPS to VM1 (root disk on shared)
self.virtual_machine_1.attach_volume(self.userapiclient,
self.zone_volumes[0]
)
verify_attach_volume(self, self.virtual_machine_1.id, self.zone_volumes[0].id)
# V7. Create a cluster wide volume and attach to vm running on zone wide storage
self.cluster_volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_1.id,
zoneid=self.zone.id
)
list_cluster_volume = Volume.list(self.userapiclient,
id=self.cluster_volume.id
)
self.assertEqual(validateList(list_cluster_volume)[0], PASS, "Check List volume response for volume %s" % self.cluster_volume.id)
self.assertEqual(list_cluster_volume[0].id, str(self.cluster_volume.id), "volume does not exist %s" % self.cluster_volume.id)
self.debug("volume id %s got created successfuly" % list_cluster_volume[0].id)
self.virtual_machine_zone_4.attach_volume(self.userapiclient,
self.cluster_volume
)
verify_attach_volume(self, self.virtual_machine_zone_4.id, self.cluster_volume.id)
if self.list_storage and self.zone.localstorageenabled:
#V8.Attach zone wide volume to vm running on local storage
self.virtual_machine_local_3.attach_volume(self.userapiclient,
self.zone_volumes[1]
)
verify_attach_volume(self, self.virtual_machine_local_3.id, self.zone_volumes[1].id)
# V9.Attach local volume to a vm running on zone wide storage
self.virtual_machine_zone_4.attach_volume(self.userapiclient,
self.local_volumes[1]
)
verify_attach_volume(self, self.virtual_machine_zone_4.id, self.local_volumes[1].id)
# 5. Detach data disk from vm1 and download it
self.virtual_machine_1.detach_volume(self.userapiclient,
volume=list_data_volume_for_vm1
)
verify_detach_volume(self, self.virtual_machine_1.id, list_data_volume_for_vm1.id)
# download detached volume
self.extract_volume = Volume.extract(self.userapiclient,
volume_id=list_data_volume_for_vm1.id,
zoneid=self.zone.id,
mode='HTTP_DOWNLOAD'
)
self.debug("extracted url is%s :" % self.extract_volume.url)
try:
formatted_url = urllib.unquote_plus(self.extract_volume.url)
self.debug("Attempting to download volume at url %s" % formatted_url)
response = urllib.urlopen(formatted_url)
self.debug("response from volume url %s" % response.getcode())
fd, path = tempfile.mkstemp()
self.debug("Saving volume %s to path %s" % (list_data_volume_for_vm1.id, path))
os.close(fd)
with open(path, 'wb') as fd:
fd.write(response.read())
self.debug("Saved volume successfully")
except Exception:
self.fail("Extract Volume Failed with invalid URL %s (vol id: %s)" % (self.extract_volume, list_data_volume_for_vm1.id))
#Need to get format for downloaded volume ,for now using default format VHD
if "OVA" in self.extract_volume.url.upper():
self.testdata["upload_volume"]["format"] = "OVA"
if "QCOW2" in self.extract_volume.url.upper():
self.testdata["upload_volume"]["format"] = "QCOW2"
# 6. Upload volume by providing url of downloaded volume in step 5
self.upload_response = Volume.upload(self.userapiclient,
zoneid=self.zone.id,
url=self.extract_volume.url,
services=self.testdata["upload_volume"]
)
self.upload_response.wait_for_upload(self.userapiclient
)
self.debug("uploaded volume id is %s" % self.upload_response.id)
# 7. Attach the volume to a different vm - vm2
self.virtual_machine_2.attach_volume(self.userapiclient,
volume=self.upload_response
)
verify_attach_volume(self, self.virtual_machine_2.id, self.upload_response.id)
# 8. Try to delete an attached volume
try:
self.volume.delete(self.userapiclient
)
self.fail("Volume got deleted in attached state %s " % self.volume.id)
except Exception as e:
self.debug("Attached volume deletion failed because %s" % e)
#9. Create template from root volume of VM1(stop VM->create template -> start vm)
self.virtual_machine_1.stop(self.userapiclient
)
self.list_root_disk_for_vm1 = Volume.list(self.userapiclient,
virtualmachineid=self.virtual_machine_1.id,
type='ROOT'
)
self.assertEqual(validateList(self.list_root_disk_for_vm1)[0], PASS, "Check List volume response for vm %s" % self.virtual_machine_1.id)
self.assertEqual(len(self.list_root_disk_for_vm1), 1, "list root disk for vm1 is empty : %s" % self.virtual_machine_1.id)
self.template_from_vm1_root_disk = Template.create(self.userapiclient,
self.testdata["template"],
self.list_root_disk_for_vm1[0].id,
account=self.account.name,
domainid=self.account.domainid
)
list_template = Template.list(self.userapiclient,
templatefilter=self.testdata["templatefilter"],
id=self.template_from_vm1_root_disk.id
)
self.assertEqual(validateList(list_template)[0], PASS, "Check List template response for template id %s" % self.template_from_vm1_root_disk.id)
self.assertEqual(len(list_template), 1, "list template response is empty for template id : %s" % list_template[0].id)
self.assertEqual(list_template[0].id, self.template_from_vm1_root_disk.id, "list template id is not same as created template")
self.debug("Template id:%s got created successfully" % self.template_from_vm1_root_disk.id)
self.virtual_machine_1.start(self.userapiclient
)
# 10. Deploy a vm using template ,created from vm1's root disk
self.virtual_machine_3 = VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template_from_vm1_root_disk.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_3.id)
# 11.delete the template created from root disk of vm1
try:
self.template_from_vm1_root_disk.delete(self.userapiclient
)
self.debug("Template id: %s got deleted successfuly" % self.template_from_vm1_root_disk.id)
except Exception as e:
raise Exception("Template deletion failed with error %s" % e)
list_template = Template.list(self.userapiclient,
templatefilter=self.testdata["templatefilter"],
id=self.template_from_vm1_root_disk.id
)
self.assertEqual(list_template, None, "Template is not deleted, id %s:" % self.template_from_vm1_root_disk.id)
self.debug("Template id%s got deleted successfully" % self.template_from_vm1_root_disk.id)
# List vm and check the state of vm
verify_vm(self, self.virtual_machine_3.id)
#12.Detach the disk from VM2 and re-attach the disk to VM1
self.virtual_machine_2.detach_volume(self.userapiclient,
volume=self.upload_response
)
verify_detach_volume(self, self.virtual_machine_2.id, self.upload_response.id)
self.virtual_machine_1.attach_volume(self.userapiclient,
volume=self.upload_response
)
verify_attach_volume(self, self.virtual_machine_1.id, self.upload_response.id)
# 15.Migrate volume(detached) and then attach to a vm and live-migrate
self.migrate_volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_1.id,
zoneid=self.zone.id
)
list_volume = Volume.list(self.apiclient,
id=self.migrate_volume.id
)
self.assertEqual(validateList(list_volume)[0], PASS, "Check List volume response for volume %s" % self.migrate_volume.id)
self.assertEqual(list_volume[0].id, str(self.migrate_volume.id), "volume does not exist %s" % self.migrate_volume.id)
self.debug("volume id %s got created successfuly" % list_volume[0].id)
self.virtual_machine_1.attach_volume(self.userapiclient,
self.migrate_volume
)
verify_attach_volume(self, self.virtual_machine_1.id, self.migrate_volume.id)
self.virtual_machine_1.detach_volume(self.userapiclient,
volume=self.migrate_volume
)
verify_detach_volume(self, self.virtual_machine_1.id, self.migrate_volume.id)
list_volume = Volume.list(self.apiclient,
id=self.migrate_volume.id
)
self.assertEqual(validateList(list_volume)[0], PASS, "Check List volume response for volume %s" % self.migrate_volume.id)
self.assertEqual(list_volume[0].id, str(self.migrate_volume.id), "volume does not exist %s" % self.migrate_volume.id)
self.debug("volume id %s got created successfuly" % list_volume[0].id)
list_pool = StoragePool.list(self.apiclient,
id=list_volume[0].storageid
)
self.assertEqual(validateList(list_pool)[0], PASS, "Check List pool response for storage id %s" % list_volume[0].storageid)
self.assertGreater(len(list_pool), 0, "Check the list list storagepoolresponse for vm id: %s" % list_volume[0].storageid)
list_pools = StoragePool.list(self.apiclient,
scope=list_pool[0].scope
)
self.assertEqual(validateList(list_pools)[0], PASS, "Check List pool response for scope %s" % list_pool[0].scope)
self.assertGreater(len(list_pools), 0, "Check the list vm response for scope :%s" % list_volume[0].scope)
storagepoolid = None
for i in range(len(list_pools)):
if list_volume[0].storageid != list_pools[i].id:
storagepoolid = list_pools[i].id
break
else:
self.debug("No pool available for volume migration ")
if storagepoolid is not None:
try:
volume_migrate = Volume.migrate(self.apiclient,
storageid=storagepoolid,
volumeid=self.migrate_volume.id
)
except Exception as e:
raise Exception("Volume migration failed with error %s" % e)
self.virtual_machine_2.attach_volume(self.userapiclient,
self.migrate_volume
)
verify_attach_volume(self, self.virtual_machine_2.id, self.migrate_volume.id)
pool_for_migration = StoragePool.listForMigration(self.apiclient,
id=self.migrate_volume.id
)
self.assertEqual(validateList(pool_for_migration)[0], PASS, "Check list pool For Migration response for volume %s" % self.migrate_volume.id)
self.assertGreater(len(pool_for_migration), 0, "Check the listForMigration response for volume :%s" % self.migrate_volume.id)
try:
volume_migrate = Volume.migrate(self.apiclient,
storageid=pool_for_migration[0].id,
volumeid=self.migrate_volume.id,
livemigrate=True
)
except Exception as e:
raise Exception("Volume migration failed with error %s" % e)
else:
try:
self.migrate_volume.delete(self.userapiclient
)
self.debug("volume id:%s got deleted successfully " % self.migrate_volume.id)
except Exception as e:
raise Exception("Volume deletion failed with error %s" % e)
# 16.Upload volume of size smaller than storage.max.volume.upload.size(leaving the negative case)
self.testdata["upload_volume"]["format"] = "VHD"
volume_upload = Volume.upload(self.userapiclient,
self.testdata["upload_volume"],
zoneid=self.zone.id
)
volume_upload.wait_for_upload(self.userapiclient
)
self.debug("volume id :%s got uploaded successfully is " % volume_upload.id)
# 20.Detach data disk from vm 2 and delete the volume
self.virtual_machine_2.detach_volume(self.userapiclient,
volume=self.volume
)
verify_detach_volume(self, self.virtual_machine_2.id, self.volume.id)
try:
self.volume.delete(self.userapiclient
)
self.debug("volume id:%s got deleted successfully " % self.volume.id)
except Exception as e:
raise Exception("Volume deletion failed with error %s" % e)
def test_02_negative_path(self):
"""
negative test for volume life cycle
# 1. Deploy a vm [vm1] with shared storage and data disk
#v1. Create VM2 with local storage offering disk offerings
# 2.TBD
# 3. Detach the data disk from VM1 and Download the volume
# 4.TBD
# 5. Attach volume with deviceid = 0
# 6. Attach volume, specify a VM which is destroyed
# 7.TBD
# 8.TBD
# 9.TBD
# 10.TBD
# 11.Upload the volume from T3 by providing the URL of the downloaded
volume, but specify a wrong format (not supported by the
hypervisor)
# 12.Upload the same volume from T4 by providing a wrong URL
# 13.Upload volume, provide wrong checksum
# 14.Upload a volume when maximum limit for the account is reached
# 15.TBD
# 16.Upload volume with all correct parameters
(covered in positive test path)
# 17.TBD
# 18.TBD
# 19.Now attach the volume with all correct parameters
(covered in positive test path)
# 20.Destroy and expunge all VMs
"""
# 1. Deploy a vm [vm1] with shared storage and data disk
self.virtual_machine_1 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
diskofferingid=self.disk_offering_1.id,
mode=self.testdata["mode"])
verify_vm(self, self.virtual_machine_1.id)
# List data volume for vm1
list_volume = Volume.list(self.userapiclient,
virtualmachineid=self.virtual_machine_1.id,
type='DATADISK'
)
self.assertEqual(
validateList(list_volume)[0],
PASS,
"Check List volume response for vm id %s" %
self.virtual_machine_1.id)
list_data_volume_for_vm1 = list_volume[0]
self.assertEqual(
len(list_volume),
1,
"There is no data disk attached to vm id:%s" %
self.virtual_machine_1.id)
self.assertEqual(
list_data_volume_for_vm1.virtualmachineid, str(
self.virtual_machine_1.id),
"Check if volume state (attached) is reflected")
# Variance
if self.zone.localstorageenabled:
# V1.Create vm3 with local storage offering
self.virtual_machine_local_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_2.id,
zoneid=self.zone.id,
mode=self.testdata["mode"])
verify_vm(self, self.virtual_machine_local_2.id)
# 3. Detach the data disk from VM1 and Download the volume
self.virtual_machine_1.detach_volume(self.userapiclient,
volume=list_data_volume_for_vm1
)
verify_detach_volume(
self,
self.virtual_machine_1.id,
list_data_volume_for_vm1.id)
# download detached volume
self.extract_volume = Volume.extract(
self.userapiclient,
volume_id=list_data_volume_for_vm1.id,
zoneid=self.zone.id,
mode='HTTP_DOWNLOAD')
self.debug("extracted url is%s :" % self.extract_volume.url)
try:
formatted_url = urllib.unquote_plus(self.extract_volume.url)
self.debug(
"Attempting to download volume at url %s" %
formatted_url)
response = urllib.urlopen(formatted_url)
self.debug("response from volume url %s" % response.getcode())
fd, path = tempfile.mkstemp()
self.debug(
"Saving volume %s to path %s" %
(list_data_volume_for_vm1.id, path))
os.close(fd)
with open(path, 'wb') as fd:
fd.write(response.read())
self.debug("Saved volume successfully")
except Exception:
self.fail(
"Extract Volume Failed with invalid URL %s (vol id: %s)" %
(self.extract_volume, list_data_volume_for_vm1.id))
# 6. Attach volume, specify a VM which is destroyed
self.virtual_machine_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
mode=self.testdata["mode"])
verify_vm(self, self.virtual_machine_2.id)
try:
self.virtual_machine_2.delete(self.apiclient)
except Exception as e:
raise Exception("Vm deletion failed with error %s" % e)
# Create a new volume
self.volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_1.id,
zoneid=self.zone.id
)
list_data_volume = Volume.list(self.userapiclient,
id=self.volume.id
)
self.assertEqual(
validateList(list_data_volume)[0],
PASS,
"Check List volume response for volume %s" %
self.volume.id)
self.assertEqual(
list_data_volume[0].id,
self.volume.id,
"check list volume response for volume id: %s" %
self.volume.id)
self.debug(
"volume id %s got created successfully" %
list_data_volume[0].id)
# try Attach volume to vm2
try:
self.virtual_machine_2.attach_volume(self.userapiclient,
self.volume
)
self.fail("Volume got attached to a destroyed vm ")
except Exception:
self.debug("Volume cant not be attached to a destroyed vm ")
# 11.Upload the volume by providing the URL of the downloaded
# volume, but specify a wrong format (not supported by the hypervisor)
if "OVA" in self.extract_volume.url.upper():
self.testdata["configurableData"]["upload_volume"]["format"] = "VHD"
else:
self.testdata["configurableData"]["upload_volume"]["format"] = "OVA"
try:
self.upload_response = Volume.upload(
self.userapiclient,
zoneid=self.zone.id,
url=self.extract_volume.url,
services=self.testdata["configurableData"]["upload_volume"])
self.fail("Volume got uploaded with invalid format")
except Exception as e:
self.debug("upload volume failed due %s" % e)
# 12. Upload the same volume from T4 by providing a wrong URL
self.testdata["configurableData"]["upload_volume"]["format"] = "VHD"
if "OVA" in self.extract_volume.url.upper():
self.testdata["configurableData"]["upload_volume"]["format"] = "OVA"
if "QCOW2" in self.extract_volume.url.upper():
self.testdata["configurableData"]["upload_volume"]["format"] = "QCOW2"
u1 = self.extract_volume.url.split('.')
u1[-2] = "wrong"
wrong_url = ".".join(u1)
try:
self.upload_response = Volume.upload(
self.userapiclient,
zoneid=self.zone.id,
url=wrong_url,
services=self.testdata["configurableData"]["upload_volume"])
self.upload_response.wait_for_upload(self.userapiclient
)
self.fail("volume got uploaded with wrong url")
except Exception as e:
self.debug("upload volume failed due to %s" % e)
# 13.Upload volume, provide wrong checksum
try:
self.upload_response = Volume.upload(
self.userapiclient,
zoneid=self.zone.id,
url=self.extract_volume.url,
services=self.testdata["configurableData"]["upload_volume"],
checksome="123456")
self.upload_response.wait_for_upload(self.userapiclient
)
self.fail("volume got uploaded with wrong checksome")
except Exception as e:
self.debug("upload volume failed due to %s" % e)
# 14.Upload a volume when maximum limit for the account is reached
account_update = Resources.updateLimit(self.apiclient,
resourcetype=2,
account=self.account.name,
domainid=self.account.domainid,
max=1
)
list_resource = Resources.list(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
resourcetype=2
)
self.assertEqual(
validateList(list_resource)[0],
PASS,
"Check List resource response for volume %s" %
self.account.name)
self.assertEqual(
str(
list_resource[0].max),
'1',
"check list List resource response for account id: %s" %
self.account.name)
self.debug(
"Max resources got updated successfully for account %s" %
self.account.name)
try:
self.upload_response = Volume.upload(
self.userapiclient,
zoneid=self.zone.id,
url=self.extract_volume.url,
services=self.testdata["configurableData"]["upload_volume"])
self.upload_response.wait_for_upload(self.userapiclient
)
self.fail("volume got uploaded after account reached max limit for\
volumes ")
except Exception as e:
self.debug("upload volume failed due to %s" % e)
def test_02_negative_path(self):
"""
negative test for volume life cycle
# 1. Deploy a vm [vm1] with shared storage and data disk
#v1. Create VM2 with local storage offering disk offerings
# 2.TBD
# 3. Detach the data disk from VM1 and Download the volume
# 4.TBD
# 5. Attach volume with deviceid = 0
# 6. Attach volume, specify a VM which is destroyed
# 7.TBD
# 8.TBD
# 9.TBD
# 10.TBD
# 11.Upload the volume from T3 by providing the URL of the downloaded
volume, but specify a wrong format (not supported by the
hypervisor)
# 12.Upload the same volume from T4 by providing a wrong URL
# 13.Upload volume, provide wrong checksum
# 14.Upload a volume when maximum limit for the account is reached
# 15.TBD
# 16.Upload volume with all correct parameters
(covered in positive test path)
# 17.TBD
# 18.TBD
# 19.Now attach the volume with all correct parameters
(covered in positive test path)
# 20.Destroy and expunge all VMs
"""
# 1. Deploy a vm [vm1] with shared storage and data disk
self.virtual_machine_1 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
diskofferingid=self.disk_offering_1.id,
mode=self.testdata["mode"])
verify_vm(self, self.virtual_machine_1.id)
# List data volume for vm1
list_volume = Volume.list(self.userapiclient,
virtualmachineid=self.virtual_machine_1.id,
type='DATADISK')
self.assertEqual(
validateList(list_volume)[0], PASS,
"Check List volume response for vm id %s" %
self.virtual_machine_1.id)
list_data_volume_for_vm1 = list_volume[0]
self.assertEqual(
len(list_volume), 1, "There is no data disk attached to vm id:%s" %
self.virtual_machine_1.id)
self.assertEqual(list_data_volume_for_vm1.virtualmachineid,
str(self.virtual_machine_1.id),
"Check if volume state (attached) is reflected")
# Variance
if self.zone.localstorageenabled:
# V1.Create vm3 with local storage offering
self.virtual_machine_local_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_2.id,
zoneid=self.zone.id,
mode=self.testdata["mode"])
verify_vm(self, self.virtual_machine_local_2.id)
# 3. Detach the data disk from VM1 and Download the volume
self.virtual_machine_1.detach_volume(self.userapiclient,
volume=list_data_volume_for_vm1)
verify_detach_volume(self, self.virtual_machine_1.id,
list_data_volume_for_vm1.id)
# download detached volume
self.extract_volume = Volume.extract(
self.userapiclient,
volume_id=list_data_volume_for_vm1.id,
zoneid=self.zone.id,
mode='HTTP_DOWNLOAD')
self.debug("extracted url is%s :" % self.extract_volume.url)
try:
formatted_url = urllib.unquote_plus(self.extract_volume.url)
self.debug("Attempting to download volume at url %s" %
formatted_url)
response = urllib.urlopen(formatted_url)
self.debug("response from volume url %s" % response.getcode())
fd, path = tempfile.mkstemp()
self.debug("Saving volume %s to path %s" %
(list_data_volume_for_vm1.id, path))
os.close(fd)
with open(path, 'wb') as fd:
fd.write(response.read())
self.debug("Saved volume successfully")
except Exception:
self.fail(
"Extract Volume Failed with invalid URL %s (vol id: %s)" %
(self.extract_volume, list_data_volume_for_vm1.id))
# 6. Attach volume, specify a VM which is destroyed
self.virtual_machine_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
mode=self.testdata["mode"])
verify_vm(self, self.virtual_machine_2.id)
try:
self.virtual_machine_2.delete(self.apiclient)
except Exception as e:
raise Exception("Vm deletion failed with error %s" % e)
# Create a new volume
self.volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_1.id,
zoneid=self.zone.id)
list_data_volume = Volume.list(self.userapiclient, id=self.volume.id)
self.assertEqual(
validateList(list_data_volume)[0], PASS,
"Check List volume response for volume %s" % self.volume.id)
self.assertEqual(
list_data_volume[0].id, self.volume.id,
"check list volume response for volume id: %s" % self.volume.id)
self.debug("volume id %s got created successfully" %
list_data_volume[0].id)
# try Attach volume to vm2
try:
self.virtual_machine_2.attach_volume(self.userapiclient,
self.volume)
self.fail("Volume got attached to a destroyed vm ")
except Exception:
self.debug("Volume cant not be attached to a destroyed vm ")
# 11.Upload the volume by providing the URL of the downloaded
# volume, but specify a wrong format (not supported by the hypervisor)
if "OVA" in self.extract_volume.url.upper():
self.testdata["upload_volume"]["format"] = "VHD"
else:
self.testdata["upload_volume"]["format"] = "OVA"
try:
self.upload_response = Volume.upload(
self.userapiclient,
zoneid=self.zone.id,
url=self.extract_volume.url,
services=self.testdata["upload_volume"])
self.fail("Volume got uploaded with invalid format")
except Exception as e:
self.debug("upload volume failed due %s" % e)
# 12. Upload the same volume from T4 by providing a wrong URL
self.testdata["upload_volume"]["format"] = "VHD"
if "OVA" in self.extract_volume.url.upper():
self.testdata["upload_volume"]["format"] = "OVA"
if "QCOW2" in self.extract_volume.url.upper():
self.testdata["upload_volume"]["format"] = "QCOW2"
u1 = self.extract_volume.url.split('.')
u1[-2] = "wrong"
wrong_url = ".".join(u1)
try:
self.upload_response = Volume.upload(
self.userapiclient,
zoneid=self.zone.id,
url=wrong_url,
services=self.testdata["upload_volume"])
self.upload_response.wait_for_upload(self.userapiclient)
self.fail("volume got uploaded with wrong url")
except Exception as e:
self.debug("upload volume failed due to %s" % e)
# 13.Upload volume, provide wrong checksum
try:
self.upload_response = Volume.upload(
self.userapiclient,
zoneid=self.zone.id,
url=self.extract_volume.url,
services=self.testdata["upload_volume"],
checksome="123456")
self.upload_response.wait_for_upload(self.userapiclient)
self.fail("volume got uploaded with wrong checksome")
except Exception as e:
self.debug("upload volume failed due to %s" % e)
# 14.Upload a volume when maximum limit for the account is reached
account_update = Resources.updateLimit(self.apiclient,
resourcetype=2,
account=self.account.name,
domainid=self.account.domainid,
max=1)
list_resource = Resources.list(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
resourcetype=2)
self.assertEqual(
validateList(list_resource)[0], PASS,
"Check List resource response for volume %s" % self.account.name)
self.assertEqual(
str(list_resource[0].max), '1',
"check list List resource response for account id: %s" %
self.account.name)
self.debug("Max resources got updated successfully for account %s" %
self.account.name)
try:
self.upload_response = Volume.upload(
self.userapiclient,
zoneid=self.zone.id,
url=self.extract_volume.url,
services=self.testdata["upload_volume"])
self.upload_response.wait_for_upload(self.userapiclient)
self.fail("volume got uploaded after account reached max limit for\
volumes ")
except Exception as e:
self.debug("upload volume failed due to %s" % e)
def test_01_upload_and_download_snapshot(self):
list_volumes_response = list_volumes(
self.apiClient,
virtualmachineid=self.virtual_machine.id,
listall=True)
sf_util.check_list(list_volumes_response, 1, self,
"There should only be one volume in this list.")
vm_root_volume = list_volumes_response[0]
### Perform tests related to uploading a QCOW2 file to secondary storage and then moving it to managed storage
volume_name = "Volume-A"
services = {"format": TestData.file_type, "diskname": volume_name}
uploaded_volume = Volume.upload(self.apiClient,
services,
self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
url=TestData.volume_url,
diskofferingid=self.disk_offering.id)
self._wait_for_volume_state(uploaded_volume.id, "Uploaded")
uploaded_volume_id = sf_util.get_cs_volume_db_id(
self.dbConnection, uploaded_volume)
result = self._get_volume_store_ref_row(uploaded_volume_id)
self.assertEqual(len(result), 1, TestUploadDownload.assertText)
install_path = self._get_install_path(
result[0][TestData.install_path_index])
self._verify_uploaded_volume_present(install_path)
uploaded_volume = self.virtual_machine.attach_volume(
self.apiClient, uploaded_volume)
uploaded_volume = sf_util.check_and_get_cs_volume(
self, uploaded_volume.id, volume_name, self)
sf_account_id = sf_util.get_sf_account_id(
self.cs_api, self.account.id, self.primary_storage.id, self,
"The SolidFire account ID should be a non-zero integer.")
sf_volumes = sf_util.get_active_sf_volumes(self.sfe, sf_account_id)
self.assertNotEqual(
len(sf_volumes), 0,
"The length of the response for the SolidFire-volume query should not be zero."
)
sf_volume = sf_util.check_and_get_sf_volume(sf_volumes,
uploaded_volume.name, self)
sf_volume_size = sf_util.get_volume_size_with_hsr(
self.cs_api, uploaded_volume, self)
sf_util.check_size_and_iops(sf_volume, uploaded_volume, sf_volume_size,
self)
sf_vag_id = sf_util.get_vag_id(self.cs_api, self.cluster.id,
self.primary_storage.id, self)
sf_util.check_vag(sf_volume, sf_vag_id, self)
result = self._get_volume_store_ref_row(uploaded_volume_id)
self.assertEqual(len(result), 0, TestUploadDownload.assertText2)
self._verify_uploaded_volume_not_present(install_path)
### Perform tests related to extracting the contents of a volume on managed storage to a QCOW2 file
### and downloading the file
try:
# for data disk
Volume.extract(self.apiClient, uploaded_volume.id, self.zone.id,
TestData.download_mode)
raise Exception(
"The volume extraction (for the data disk) did not fail (as expected)."
)
except Exception as e:
if TestUploadDownload.errorText in str(e):
pass
else:
raise
vm_root_volume_id = sf_util.get_cs_volume_db_id(
self.dbConnection, vm_root_volume)
try:
# for root disk
Volume.extract(self.apiClient, vm_root_volume.id, self.zone.id,
TestData.download_mode)
raise Exception(
"The volume extraction (for the root disk) did not fail (as expected)."
)
except Exception as e:
if TestUploadDownload.errorText in str(e):
pass
else:
raise
self.virtual_machine.stop(self.apiClient)
self._extract_volume_and_verify(
uploaded_volume_id,
"Unable to locate the extracted file for the data disk (attached)")
result = self._get_volume_store_ref_row(vm_root_volume_id)
self.assertEqual(len(result), 0, TestUploadDownload.assertText2)
self._extract_volume_and_verify(
vm_root_volume_id,
"Unable to locate the extracted file for the root disk")
uploaded_volume = self.virtual_machine.detach_volume(
self.apiClient, uploaded_volume)
self._extract_volume_and_verify(
uploaded_volume_id,
"Unable to locate the extracted file for the data disk (detached)")
uploaded_volume = Volume(uploaded_volume.__dict__)
uploaded_volume.delete(self.apiClient)
def test_01_upload_and_download_snapshot(self):
list_volumes_response = list_volumes(
self.apiClient,
virtualmachineid=self.virtual_machine.id,
listall=True
)
sf_util.check_list(list_volumes_response, 1, self, "There should only be one volume in this list.")
vm_root_volume = list_volumes_response[0]
### Perform tests related to uploading a QCOW2 file to secondary storage and then moving it to managed storage
volume_name = "Volume-A"
services = {"format": TestData.file_type, "diskname": volume_name}
uploaded_volume = Volume.upload(self.apiClient, services, self.zone.id,
account=self.account.name, domainid=self.account.domainid,
url=TestData.volume_url, diskofferingid=self.disk_offering.id)
self._wait_for_volume_state(uploaded_volume.id, "Uploaded")
uploaded_volume_id = sf_util.get_cs_volume_db_id(self.dbConnection, uploaded_volume)
result = self._get_volume_store_ref_row(uploaded_volume_id)
self.assertEqual(
len(result),
1,
TestUploadDownload.assertText
)
install_path = self._get_install_path(result[0][TestData.install_path_index])
self._verify_uploaded_volume_present(install_path)
uploaded_volume = self.virtual_machine.attach_volume(
self.apiClient,
uploaded_volume
)
uploaded_volume = sf_util.check_and_get_cs_volume(self, uploaded_volume.id, volume_name, self)
sf_account_id = sf_util.get_sf_account_id(self.cs_api, self.account.id, self.primary_storage.id, self, "The SolidFire account ID should be a non-zero integer.")
sf_volumes = sf_util.get_active_sf_volumes(self.sfe, sf_account_id)
self.assertNotEqual(
len(sf_volumes),
0,
"The length of the response for the SolidFire-volume query should not be zero."
)
sf_volume = sf_util.check_and_get_sf_volume(sf_volumes, uploaded_volume.name, self)
sf_volume_size = sf_util.get_volume_size_with_hsr(self.cs_api, uploaded_volume, self)
sf_util.check_size_and_iops(sf_volume, uploaded_volume, sf_volume_size, self)
sf_vag_id = sf_util.get_vag_id(self.cs_api, self.cluster.id, self.primary_storage.id, self)
sf_util.check_vag(sf_volume, sf_vag_id, self)
result = self._get_volume_store_ref_row(uploaded_volume_id)
self.assertEqual(
len(result),
0,
TestUploadDownload.assertText2
)
self._verify_uploaded_volume_not_present(install_path)
### Perform tests related to extracting the contents of a volume on managed storage to a QCOW2 file
### and downloading the file
try:
# for data disk
Volume.extract(self.apiClient, uploaded_volume.id, self.zone.id, TestData.download_mode)
raise Exception("The volume extraction (for the data disk) did not fail (as expected).")
except Exception as e:
if TestUploadDownload.errorText in str(e):
pass
else:
raise
vm_root_volume_id = sf_util.get_cs_volume_db_id(self.dbConnection, vm_root_volume)
try:
# for root disk
Volume.extract(self.apiClient, vm_root_volume.id, self.zone.id, TestData.download_mode)
raise Exception("The volume extraction (for the root disk) did not fail (as expected).")
except Exception as e:
if TestUploadDownload.errorText in str(e):
pass
else:
raise
self.virtual_machine.stop(self.apiClient)
self._extract_volume_and_verify(uploaded_volume_id, "Unable to locate the extracted file for the data disk (attached)")
result = self._get_volume_store_ref_row(vm_root_volume_id)
self.assertEqual(
len(result),
0,
TestUploadDownload.assertText2
)
self._extract_volume_and_verify(vm_root_volume_id, "Unable to locate the extracted file for the root disk")
uploaded_volume = self.virtual_machine.detach_volume(
self.apiClient,
uploaded_volume
)
self._extract_volume_and_verify(uploaded_volume_id, "Unable to locate the extracted file for the data disk (detached)")
uploaded_volume = Volume(uploaded_volume.__dict__)
uploaded_volume.delete(self.apiClient)