You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by ra...@apache.org on 2014/11/13 10:42:57 UTC
[12/28] git commit: updated refs/heads/master to 8c9093b
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/85ac979f/test/integration/component/test_escalations_instances.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_escalations_instances.py b/test/integration/component/test_escalations_instances.py
index 1aaa688..7e4cfe6 100644
--- a/test/integration/component/test_escalations_instances.py
+++ b/test/integration/component/test_escalations_instances.py
@@ -16,17 +16,28 @@
# under the License.
# Import Local Modules
-from marvin.cloudstackTestCase import *
-from marvin.cloudstackException import *
-from marvin.cloudstackAPI import *
-from marvin.sshClient import SshClient
-from marvin.lib.utils import *
-from marvin.lib.base import *
-from marvin.lib.common import *
+from marvin.cloudstackTestCase import cloudstackTestCase, unittest
+from marvin.lib.utils import cleanup_resources, validateList
+from marvin.lib.base import (Account,
+ ServiceOffering,
+ NetworkOffering,
+ Network,
+ VirtualMachine,
+ SecurityGroup,
+ DiskOffering,
+ Resources,
+ Iso,
+ Configurations,
+ SSHKeyPair,
+ Volume,
+ VmSnapshot,
+ Zone)
+from marvin.lib.common import (get_zone,
+ get_template,
+ get_domain)
from marvin.codes import PASS
from nose.plugins.attrib import attr
-from time import sleep
-# from ctypes.wintypes import BOOLEAN
+
class TestListInstances(cloudstackTestCase):
@@ -40,19 +51,23 @@ class TestListInstances(cloudstackTestCase):
cls.hypervisor = cls.testClient.getHypervisorInfo()
# Get Domain, Zone, Template
cls.domain = get_domain(cls.api_client)
- cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
+ cls.zone = get_zone(
+ cls.api_client,
+ cls.testClient.getZoneForTests())
cls.template = get_template(
- cls.api_client,
- cls.zone.id,
- cls.services["ostype"]
- )
+ cls.api_client,
+ cls.zone.id,
+ cls.services["ostype"]
+ )
if cls.zone.localstorageenabled:
cls.storagetype = 'local'
- cls.services["service_offerings"]["tiny"]["storagetype"] = 'local'
+ cls.services["service_offerings"][
+ "tiny"]["storagetype"] = 'local'
cls.services["disk_offering"]["storagetype"] = 'local'
else:
cls.storagetype = 'shared'
- cls.services["service_offerings"]["tiny"]["storagetype"] = 'shared'
+ cls.services["service_offerings"][
+ "tiny"]["storagetype"] = 'shared'
cls.services["disk_offering"]["storagetype"] = 'shared'
cls.services['mode'] = cls.zone.networktype
@@ -62,32 +77,13 @@ class TestListInstances(cloudstackTestCase):
cls.services["custom_volume"]["zoneid"] = cls.zone.id
# Creating Disk offering, Service Offering and Account
cls.disk_offering = DiskOffering.create(
- cls.api_client,
- cls.services["disk_offering"]
- )
+ cls.api_client,
+ cls.services["disk_offering"]
+ )
cls.service_offering = ServiceOffering.create(
- cls.api_client,
- cls.services["service_offerings"]["tiny"]
- )
- cls.account = Account.create(
- cls.api_client,
- cls.services["account"],
- domainid=cls.domain.id
- )
- # Getting authentication for user in newly created Account
- cls.user = cls.account.user[0]
- cls.userapiclient = cls.testClient.getUserApiClient(cls.user.username, cls.domain.name)
- # Updating resource Limits
- for i in range(0, 12):
- Resources.updateLimit(
- cls.api_client,
- account=cls.account.name,
- domainid=cls.domain.id,
- max=-1,
- resourcetype=i
- )
-
- cls._cleanup.append(cls.account)
+ cls.api_client,
+ cls.services["service_offerings"]["tiny"]
+ )
cls._cleanup.append(cls.service_offering)
cls._cleanup.append(cls.disk_offering)
except Exception as e:
@@ -98,7 +94,27 @@ class TestListInstances(cloudstackTestCase):
def setUp(self):
self.apiClient = self.testClient.getApiClient()
- self.cleanup = []
+ self.account = Account.create(
+ self.apiClient,
+ self.services["account"],
+ domainid=self.domain.id
+ )
+ # Getting authentication for user in newly created Account
+ self.user = self.account.user[0]
+ self.userapiclient = self.testClient.getUserApiClient(
+ self.user.username,
+ self.domain.name)
+ # Updating resource Limits
+ for i in range(0, 12):
+ Resources.updateLimit(
+ self.api_client,
+ account=self.account.name,
+ domainid=self.domain.id,
+ max=-1,
+ resourcetype=i
+ )
+
+ self.cleanup = [self.account, ]
def tearDown(self):
# Clean up, terminate the created resources
@@ -115,14 +131,15 @@ class TestListInstances(cloudstackTestCase):
return
def __verify_values(self, expected_vals, actual_vals):
- """
+ """
@Desc: Function to verify expected and actual values
@Steps:
Step1: Initializing return flag to True
- Step1: Verifying length of expected and actual dictionaries is matching.
+ Step1: Verifying length of expected and actual dictionaries is matching
If not matching returning false
Step2: Listing all the keys from expected dictionary
- Step3: Looping through each key from step2 and verifying expected and actual dictionaries have same value
+ Step3: Looping through each key from step2 and verifying expected and
+ actual dictionaries have same value
If not making return flag to False
Step4: returning the return flag after all the values are verified
"""
@@ -139,24 +156,26 @@ class TestListInstances(cloudstackTestCase):
return_flag = return_flag and True
else:
return_flag = return_flag and False
- self.debug("expected Value: %s, is not matching with actual value: %s" % (
- exp_val,
- act_val
- ))
+ self.debug(
+ "expected Value: %s, is not matching with\
+ actual value: %s" %
+ (exp_val, act_val))
return return_flag
@attr(tags=["advanced", "basic"], required_hardware="false")
def test_01_list_instances_pagination(self):
- """
+ """
@Desc: Test List Instances pagination
@Steps:
Step1: Listing all the Instances for a user
Step2: Verifying listed Instances for account created at class level
- Step3: If number of volumes is less than (page size + 1), then creating them
+ Step3: If number of volumes is less than
+ (page size + 1), then creating them
Step4: Listing all the volumes again after creation of volumes
Step5: Verifying the length of the volumes is (page size + 1)
Step6: Listing all the volumes in page1
- Step7: Verifying that the length of the volumes in page 1 is (page size)
+ Step7: Verifying that the length of the volumes in page 1 is
+ (page size)
Step8: Listing all the volumes in page2
Step9: Verifying that the length of the volumes in page 2 is 1
Step10: Deleting the volume present in page 2
@@ -164,124 +183,128 @@ class TestListInstances(cloudstackTestCase):
Step12: Verifying that there are no volumes present in page 2
"""
# Listing all the instances for a user
- list_instances_before = VirtualMachine.list(self.userapiclient, listall=self.services["listall"])
+ list_instances_before = VirtualMachine.list(
+ self.userapiclient,
+ listall=self.services["listall"])
# Verifying listed instances for account created at class level
self.assertIsNone(
- list_instances_before,
- "Virtual Machine already exists for newly created user"
- )
- # If number of instances are less than (pagesize + 1), then creating them
+ list_instances_before,
+ "Virtual Machine already exists for newly created user"
+ )
+ # If number of instances are less than (pagesize + 1), then creating
+ # them
for i in range(0, (self.services["pagesize"] + 1)):
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- if(i < (self.services["pagesize"])):
- self.cleanup.append(vm_created)
+ vm_created,
+ "VM creation failed"
+ )
self.assertEqual(
- self.services["virtual_machine"]["displayname"],
- vm_created.displayname,
- "Newly created VM name and the test data VM name are not matching"
- )
+ self.services["virtual_machine"]["displayname"],
+ vm_created.displayname,
+ "Newly created VM name and the test data VM name\
+ are not matching")
# Listing all the instances again after creating VM's
- list_instances_after = VirtualMachine.list(self.userapiclient, listall=self.services["listall"])
+ list_instances_after = VirtualMachine.list(
+ self.userapiclient,
+ listall=self.services["listall"])
status = validateList(list_instances_after)
self.assertEquals(
- PASS,
- status[0],
- "Listing of instances after creation failed"
- )
+ PASS,
+ status[0],
+ "Listing of instances after creation failed"
+ )
# Verifying the length of the instances is (page size + 1)
self.assertEqual(
- len(list_instances_after),
- (self.services["pagesize"] + 1),
- "Number of instances created is not matching as expected"
- )
+ len(list_instances_after),
+ (self.services["pagesize"] + 1),
+ "Number of instances created is not matching as expected"
+ )
# Listing all the volumes in page1
list_instances_page1 = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid
+ )
status = validateList(list_instances_page1)
self.assertEquals(
- PASS,
- status[0],
- "Listing of instances in page1 failed"
- )
+ PASS,
+ status[0],
+ "Listing of instances in page1 failed"
+ )
# Verifying that the length of the instances in page 1 is (page size)
self.assertEqual(
- self.services["pagesize"],
- len(list_instances_page1),
- "List VM response is not matching with the page size length for page 1"
- )
+ self.services["pagesize"],
+ len(list_instances_page1),
+ "List VM response is not matching with the page size\
+ length for page 1")
# Listing all the VM's in page2
list_instances_page2 = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=2,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=2,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid
+ )
status = validateList(list_instances_page2)
self.assertEquals(
- PASS,
- status[0],
- "Listing of instances in page2 failed"
- )
+ PASS,
+ status[0],
+ "Listing of instances in page2 failed"
+ )
# Verifying that the length of the VM's in page 2 is 1
self.assertEqual(
- 1,
- len(list_instances_page2),
- "List VM response is not matching with the page size length for page 2"
- )
+ 1,
+ len(list_instances_page2),
+ "List VM response is not matching with the\
+ page size length for page 2"
+ )
instance_page2 = list_instances_page2[0]
# Verifying that the VM on page 2 is not present in page1
for i in range(0, len(list_instances_page1)):
instance_page1 = list_instances_page1[i]
self.assertNotEquals(
- instance_page2.id,
- instance_page1.id,
- "VM listed in page 2 is also listed in page 1"
- )
+ instance_page2.id,
+ instance_page1.id,
+ "VM listed in page 2 is also listed in page 1"
+ )
# Deleting a single VM
- VirtualMachine.delete(vm_created, self.userapiclient, expunge=True)
+ VirtualMachine.delete(vm_created, self.apiClient, expunge=True)
# Listing the VM's in page 2
list_instance_response = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=2,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=2,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid
+ )
# verifying that VM does not exists on page 2
self.assertEqual(
- list_instance_response,
- None,
- "VM was not deleted"
- )
+ list_instance_response,
+ None,
+ "VM was not deleted"
+ )
return
@attr(tags=["advanced", "basic"], required_hardware="false")
def test_02_list_Running_vm(self):
- """
+ """
@Desc: Test List Running VM's
@Steps:
Step1: Listing all the Running VMs for a user
@@ -289,90 +312,90 @@ class TestListInstances(cloudstackTestCase):
Step3: Deploying a VM
Step4: Listing all the Running VMs for a user again
Step5: Verifying that the size of the list is increased by 1
- Step6: Verifying that the details of the Running VM listed are same as the VM deployed in Step3
+ Step6: Verifying that the details of the Running VM listed are
+ same as the VM deployed in Step3
"""
# Listing all the Running VM's for a User
list_running_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Running"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ state="Running"
+ )
self.assertIsNone(
- list_running_vms_before,
- "Virtual Machine already exists for newly created user"
- )
+ list_running_vms_before,
+ "Virtual Machine already exists for newly created user"
+ )
# Deploying a VM
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
+ vm_created,
+ "VM creation failed"
+ )
# Listing all the Running VM's for a User
list_running_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Running"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ state="Running"
+ )
status = validateList(list_running_vms_after)
self.assertEquals(
- PASS,
- status[0],
- "Newly created VM is not in Running state"
- )
+ PASS,
+ status[0],
+ "Newly created VM is not in Running state"
+ )
# Verifying list size is 1
self.assertEquals(
- 1,
- len(list_running_vms_after),
- "Running VM list count is not matching"
- )
+ 1,
+ len(list_running_vms_after),
+ "Running VM list count is not matching"
+ )
running_vm = list_running_vms_after[0]
# Creating expected and actual values dictionaries
expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":"Running",
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
+ "id": vm_created.id,
+ "name": vm_created.name,
+ "displayname": vm_created.displayname,
+ "state": "Running",
+ "zoneid": vm_created.zoneid,
+ "account": vm_created.account,
+ "template": vm_created.templateid
+ }
actual_dict = {
- "id":running_vm.id,
- "name":running_vm.name,
- "displayname":running_vm.displayname,
- "state":running_vm.state,
- "zoneid":running_vm.zoneid,
- "account":running_vm.account,
- "template":running_vm.templateid
- }
+ "id": running_vm.id,
+ "name": running_vm.name,
+ "displayname": running_vm.displayname,
+ "state": running_vm.state,
+ "zoneid": running_vm.zoneid,
+ "account": running_vm.account,
+ "template": running_vm.templateid
+ }
running_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
+ expected_dict,
+ actual_dict
+ )
self.assertEqual(
- True,
- running_vm_status,
- "Listed Running VM details are not as expected"
- )
+ True,
+ running_vm_status,
+ "Listed Running VM details are not as expected"
+ )
return
@attr(tags=["advanced", "basic"], required_hardware="false")
def test_03_list_Stopped_vm(self):
- """
+ """
@Desc: Test List Stopped VM's
@Steps:
Step1: Listing all the Stopped VMs for a user
@@ -381,86 +404,86 @@ class TestListInstances(cloudstackTestCase):
Step4: Stopping the VM deployed in step3
Step5: Listing all the Stopped VMs for a user again
Step6: Verifying that the size of the list is increased by 1
- Step7: Verifying that the details of the Stopped VM listed are same as the VM stopped in Step4
+ Step7: Verifying that the details of the Stopped VM listed are
+ same as the VM stopped in Step4
"""
# Listing all the Stopped VM's for a User
list_stopped_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Stopped"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ state="Stopped"
+ )
self.assertIsNone(
- list_stopped_vms_before,
- "Virtual Machine already exists for newly created user"
- )
+ list_stopped_vms_before,
+ "Virtual Machine already exists for newly created user"
+ )
# Deploying a VM
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
+ vm_created,
+ "VM creation failed"
+ )
# Stopping the VM
VirtualMachine.stop(vm_created, self.userapiclient)
# Listing all the Stopped VM's for a User
list_stopped_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Stopped"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ state="Stopped"
+ )
status = validateList(list_stopped_vms_after)
self.assertEquals(
- PASS,
- status[0],
- "Stopped VM is not in Stopped state"
- )
+ PASS,
+ status[0],
+ "Stopped VM is not in Stopped state"
+ )
# Verifying list size is 1
self.assertEquals(
- 1,
- len(list_stopped_vms_after),
- "Stopped VM list count is not matching"
- )
+ 1,
+ len(list_stopped_vms_after),
+ "Stopped VM list count is not matching"
+ )
stopped_vm = list_stopped_vms_after[0]
# Creating expected and actual values dictionaries
expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":"Stopped",
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
+ "id": vm_created.id,
+ "name": vm_created.name,
+ "displayname": vm_created.displayname,
+ "state": "Stopped",
+ "zoneid": vm_created.zoneid,
+ "account": vm_created.account,
+ "template": vm_created.templateid
+ }
actual_dict = {
- "id":stopped_vm.id,
- "name":stopped_vm.name,
- "displayname":stopped_vm.displayname,
- "state":stopped_vm.state,
- "zoneid":stopped_vm.zoneid,
- "account":stopped_vm.account,
- "template":stopped_vm.templateid
- }
+ "id": stopped_vm.id,
+ "name": stopped_vm.name,
+ "displayname": stopped_vm.displayname,
+ "state": stopped_vm.state,
+ "zoneid": stopped_vm.zoneid,
+ "account": stopped_vm.account,
+ "template": stopped_vm.templateid
+ }
stopped_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
+ expected_dict,
+ actual_dict
+ )
self.assertEqual(
- True,
- stopped_vm_status,
- "Listed Stopped VM details are not as expected"
- )
+ True,
+ stopped_vm_status,
+ "Listed Stopped VM details are not as expected"
+ )
return
@attr(tags=["advanced", "basic"], required_hardware="false")
@@ -476,99 +499,100 @@ class TestListInstances(cloudstackTestCase):
Step6: Verifying that destroyed VM is not listed for User
Step7: Listing all the destroyed VMs as admin
Step8: Verifying that the size of the list is 1
- Step9: Verifying that the details of the Destroyed VM listed are same as the VM destroyed in Step4
+ Step9: Verifying that the details of the Destroyed VM listed
+ are same as the VM destroyed in Step4
"""
# Listing all the Destroyed VM's for a User
list_destroyed_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Destroyed"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ state="Destroyed"
+ )
self.assertIsNone(
- list_destroyed_vms_before,
- "Virtual Machine in Destroyed state already exists for newly created user"
- )
+ list_destroyed_vms_before,
+ "Virtual Machine in Destroyed state already exists\
+ for newly created user")
# Deploying a VM
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
+ vm_created,
+ "VM creation failed"
+ )
# Destroying the VM
VirtualMachine.delete(vm_created, self.userapiclient, expunge=False)
# Listing all the Destroyed VM's for a User
list_destroyed_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Destroyed"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ state="Destroyed"
+ )
self.assertIsNone(
- list_destroyed_vms_after,
- "Destroyed VM is not in destroyed state"
- )
+ list_destroyed_vms_after,
+ "Destroyed VM is not in destroyed state"
+ )
# Listing destroyed VMs as admin user
list_destroyed_vms_admin = VirtualMachine.list(
- self.apiClient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Destroyed",
- id=vm_created.id
- )
+ self.apiClient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ state="Destroyed",
+ id=vm_created.id
+ )
status = validateList(list_destroyed_vms_admin)
self.assertEquals(
- PASS,
- status[0],
- "Destroyed VM is not in Destroyed state"
- )
+ PASS,
+ status[0],
+ "Destroyed VM is not in Destroyed state"
+ )
# Verifying that the length of the destroyed VMs list should be 1
self.assertEquals(
- 1,
- len(list_destroyed_vms_admin),
- "Destroyed VM list count is not matching"
- )
+ 1,
+ len(list_destroyed_vms_admin),
+ "Destroyed VM list count is not matching"
+ )
destroyed_vm = list_destroyed_vms_admin[0]
# Creating expected and actual values dictionaries
expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":"Destroyed",
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
+ "id": vm_created.id,
+ "name": vm_created.name,
+ "displayname": vm_created.displayname,
+ "state": "Destroyed",
+ "zoneid": vm_created.zoneid,
+ "account": vm_created.account,
+ "template": vm_created.templateid
+ }
actual_dict = {
- "id":destroyed_vm.id,
- "name":destroyed_vm.name,
- "displayname":destroyed_vm.displayname,
- "state":destroyed_vm.state,
- "zoneid":destroyed_vm.zoneid,
- "account":destroyed_vm.account,
- "template":destroyed_vm.templateid
- }
+ "id": destroyed_vm.id,
+ "name": destroyed_vm.name,
+ "displayname": destroyed_vm.displayname,
+ "state": destroyed_vm.state,
+ "zoneid": destroyed_vm.zoneid,
+ "account": destroyed_vm.account,
+ "template": destroyed_vm.templateid
+ }
destroyed_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
+ expected_dict,
+ actual_dict
+ )
self.assertEqual(
- True,
- destroyed_vm_status,
- "Listed Destroyed VM details are not as expected"
- )
+ True,
+ destroyed_vm_status,
+ "Listed Destroyed VM details are not as expected"
+ )
return
@attr(tags=["advanced", "basic"], required_hardware="false")
@@ -582,95 +606,95 @@ class TestListInstances(cloudstackTestCase):
Step4: Listing all the VMs for a user again
Step5: Verifying that the size of the list is increased by 1
Step6: List a VM by specifying the Id if the VM deployed in Step3
- Step7: Verifying that the details of the Listed VM are same as the VM deployed in Step3
+ Step7: Verifying that the details of the Listed VM are same as
+ the VM deployed in Step3
"""
# Listing all the VM's for a User
list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- account=self.account.name
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ account=self.account.name
+ )
self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
+ list_vms_before,
+ "Virtual Machine already exists for newly created user"
+ )
# Deploying a VM
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
+ vm_created,
+ "VM creation failed"
+ )
# Listing all the VM's for a User
list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- account=self.account.name
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ account=self.account.name
+ )
status = validateList(list_vms_after)
self.assertEquals(
- PASS,
- status[0],
- "Listing of VM after creation failed"
- )
+ PASS,
+ status[0],
+ "Listing of VM after creation failed"
+ )
self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
+ 1,
+ len(list_vms_after),
+ "VM list count is not matching"
+ )
# Listing a VM by Id
list_vm_byid = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- id=vm_created.id
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ id=vm_created.id
+ )
status = validateList(list_vm_byid)
self.assertEquals(
- PASS,
- status[0],
- "Listing of VM by Id failed"
- )
+ PASS,
+ status[0],
+ "Listing of VM by Id failed"
+ )
listed_vm = list_vm_byid[0]
# Creating expected and actual values dictionaries
expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":vm_created.state,
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
+ "id": vm_created.id,
+ "name": vm_created.name,
+ "displayname": vm_created.displayname,
+ "state": vm_created.state,
+ "zoneid": vm_created.zoneid,
+ "account": vm_created.account,
+ "template": vm_created.templateid
+ }
actual_dict = {
- "id":listed_vm.id,
- "name":listed_vm.name,
- "displayname":listed_vm.displayname,
- "state":listed_vm.state,
- "zoneid":listed_vm.zoneid,
- "account":listed_vm.account,
- "template":listed_vm.templateid
- }
+ "id": listed_vm.id,
+ "name": listed_vm.name,
+ "displayname": listed_vm.displayname,
+ "state": listed_vm.state,
+ "zoneid": listed_vm.zoneid,
+ "account": listed_vm.account,
+ "template": listed_vm.templateid
+ }
list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
+ expected_dict,
+ actual_dict
+ )
self.assertEqual(
- True,
- list_vm_status,
- "Listed VM by Id details are not as expected"
- )
+ True,
+ list_vm_status,
+ "Listed VM by Id details are not as expected"
+ )
return
@attr(tags=["advanced", "basic"], required_hardware="false")
@@ -683,134 +707,136 @@ class TestListInstances(cloudstackTestCase):
Step3: Deploying a 2 VM's
Step4: Listing all the VMs for a user again
Step5: Verifying that list size is increased by 2
- Step6: Listing the VM by specifying complete name of VM-1 created in step3
+ Step6: Listing the VM by specifying complete name of
+ VM-1 created in step3
Step7: Verifying that the size of the list is 1
- Step8: Verifying that the details of the listed VM are same as the VM-1 created in step3
+ Step8: Verifying that the details of the listed VM are same as the
+ VM-1 created in step3
Step9: Listing the VM by specifying the partial name of VM
Step10: Verifying that the size of the list is 2
"""
# Listing all the VM's for a User
list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ )
self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
+ list_vms_before,
+ "Virtual Machine already exists for newly created user"
+ )
vms = {}
for i in range(0, 2):
# Deploying a VM
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
+ vm_created,
+ "VM creation failed"
+ )
vms.update({i: vm_created})
# Listing all the VM's for a User
list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ )
status = validateList(list_vms_after)
self.assertEquals(
- PASS,
- status[0],
- "VM's creation failed"
- )
+ PASS,
+ status[0],
+ "VM's creation failed"
+ )
self.assertEquals(
- 2,
- len(list_vms_after),
- "VM's list count is not matching"
- )
+ 2,
+ len(list_vms_after),
+ "VM's list count is not matching"
+ )
# Listing the VM by complete name
list_vm_byfullname = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- name=vms[0].name
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ name=vms[0].name
+ )
status = validateList(list_vm_byfullname)
self.assertEquals(
- PASS,
- status[0],
- "Failed to list VM by Name"
- )
+ PASS,
+ status[0],
+ "Failed to list VM by Name"
+ )
# Verifying that the size of the list is 1
self.assertEquals(
- 1,
- len(list_vm_byfullname),
- "VM list by full name count is not matching"
- )
- # Verifying that the details of the listed VM are same as the VM created above
+ 1,
+ len(list_vm_byfullname),
+ "VM list by full name count is not matching"
+ )
+ # Verifying that the details of the listed VM are same
+ # as the VM created above
# Creating expected and actual values dictionaries
expected_dict = {
- "id":vms[0].id,
- "name":vms[0].name,
- "displayname":vms[0].displayname,
- "state":vms[0].state,
- "zoneid":vms[0].zoneid,
- "account":vms[0].account,
- "template":vms[0].templateid
- }
+ "id": vms[0].id,
+ "name": vms[0].name,
+ "displayname": vms[0].displayname,
+ "state": vms[0].state,
+ "zoneid": vms[0].zoneid,
+ "account": vms[0].account,
+ "template": vms[0].templateid
+ }
actual_dict = {
- "id":list_vm_byfullname[0].id,
- "name":list_vm_byfullname[0].name,
- "displayname":list_vm_byfullname[0].displayname,
- "state":list_vm_byfullname[0].state,
- "zoneid":list_vm_byfullname[0].zoneid,
- "account":list_vm_byfullname[0].account,
- "template":list_vm_byfullname[0].templateid
- }
+ "id": list_vm_byfullname[0].id,
+ "name": list_vm_byfullname[0].name,
+ "displayname": list_vm_byfullname[0].displayname,
+ "state": list_vm_byfullname[0].state,
+ "zoneid": list_vm_byfullname[0].zoneid,
+ "account": list_vm_byfullname[0].account,
+ "template": list_vm_byfullname[0].templateid
+ }
list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
+ expected_dict,
+ actual_dict
+ )
self.assertEqual(
- True,
- list_vm_status,
- "Listed VM details are not as expected"
- )
+ True,
+ list_vm_status,
+ "Listed VM details are not as expected"
+ )
# Listing the VM by partial name
list_vm_bypartialname = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- domainid=self.account.domainid,
- name=vms[0].name[:1]
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ domainid=self.account.domainid,
+ name=vms[0].name[:1]
+ )
status = validateList(list_vm_bypartialname)
self.assertEquals(
- PASS,
- status[0],
- "Failed to list VM by Name"
- )
+ PASS,
+ status[0],
+ "Failed to list VM by Name"
+ )
# Verifying that the size of the list is 2
self.assertEquals(
- 2,
- len(list_vm_bypartialname),
- "VM list by full name count is not matching"
- )
+ 2,
+ len(list_vm_bypartialname),
+ "VM list by full name count is not matching"
+ )
return
@attr(tags=["advanced", "basic"], required_hardware="false")
def test_07_list_vm_by_name_state(self):
- """
+ """
@Desc: Test List VM's by Name and State
@Steps:
Step1: Listing all the VMs for a user
@@ -818,143 +844,147 @@ class TestListInstances(cloudstackTestCase):
Step3: Deploying a VM
Step4: Listing all the VMs for a user again
Step5: Verifying that list size is increased by 1
- Step6: Listing the VM by specifying name of VM created in step3 and state as Running (matching name and state)
+ Step6: Listing the VM by specifying name of VM created in step3 and
+ state as Running (matching name and state)
Step7: Verifying that the size of the list is 1
- Step8: Verifying that the details of the listed VM are same as the VM created in step3
- Step9: Listing the VM by specifying name of VM created in step3 and state as Stopped (non matching state)
+ Step8: Verifying that the details of the listed VM are same as
+ the VM created in step3
+ Step9: Listing the VM by specifying name of VM created in step3
+ and state as Stopped (non matching state)
Step10: Verifying that the size of the list is 0
- Step11: Listing the VM by specifying non matching name and state as Running (non matching name)
+ Step11: Listing the VM by specifying non matching name and
+ state as Running (non matching name)
Step12: Verifying that the size of the list is 0
"""
# Listing all the VM's for a User
list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ )
self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
+ list_vms_before,
+ "Virtual Machine already exists for newly created user"
+ )
# Deploying a VM
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
+ vm_created,
+ "VM creation failed"
+ )
# Listing all the VM's for a User
list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ )
status = validateList(list_vms_after)
self.assertEquals(
- PASS,
- status[0],
- "VM's creation failed"
- )
+ PASS,
+ status[0],
+ "VM's creation failed"
+ )
self.assertEquals(
- 1,
- len(list_vms_after),
- "VM's list count is not matching"
- )
+ 1,
+ len(list_vms_after),
+ "VM's list count is not matching"
+ )
# Listing the VM by matching Name and State
list_running_vm = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- name=vm_created.name,
- state="Running"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ name=vm_created.name,
+ state="Running"
+ )
status = validateList(list_running_vm)
self.assertEquals(
- PASS,
- status[0],
- "List VM by name and state failed"
- )
+ PASS,
+ status[0],
+ "List VM by name and state failed"
+ )
# Verifying that the size of the list is 1
self.assertEquals(
- 1,
- len(list_running_vm),
- "Count of VM list by name and state is not matching"
- )
- # Verifying that the details of the listed VM are same as the VM created above
+ 1,
+ len(list_running_vm),
+ "Count of VM list by name and state is not matching"
+ )
+ # Verifying that the details of the listed VM are same
+ # as the VM created above
# Creating expected and actual values dictionaries
expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":"Running",
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
+ "id": vm_created.id,
+ "name": vm_created.name,
+ "displayname": vm_created.displayname,
+ "state": "Running",
+ "zoneid": vm_created.zoneid,
+ "account": vm_created.account,
+ "template": vm_created.templateid
+ }
actual_dict = {
- "id":list_running_vm[0].id,
- "name":list_running_vm[0].name,
- "displayname":list_running_vm[0].displayname,
- "state":list_running_vm[0].state,
- "zoneid":list_running_vm[0].zoneid,
- "account":list_running_vm[0].account,
- "template":list_running_vm[0].templateid
- }
+ "id": list_running_vm[0].id,
+ "name": list_running_vm[0].name,
+ "displayname": list_running_vm[0].displayname,
+ "state": list_running_vm[0].state,
+ "zoneid": list_running_vm[0].zoneid,
+ "account": list_running_vm[0].account,
+ "template": list_running_vm[0].templateid
+ }
list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
+ expected_dict,
+ actual_dict
+ )
self.assertEqual(
- True,
- list_vm_status,
- "Listed VM details are not as expected"
- )
+ True,
+ list_vm_status,
+ "Listed VM details are not as expected"
+ )
# Listing the VM by matching name and non matching state
list_running_vm = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- name=vm_created.name,
- state="Stopped"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ name=vm_created.name,
+ state="Stopped"
+ )
self.assertIsNone(
- list_running_vm,
- "Listed VM with non matching state"
- )
+ list_running_vm,
+ "Listed VM with non matching state"
+ )
# Listing the VM by non matching name and matching state
list_running_vm = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- name="name",
- state="Running"
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ name="name",
+ state="Running"
+ )
self.assertIsNone(
- list_running_vm,
- "Listed VM with non matching name"
- )
+ list_running_vm,
+ "Listed VM with non matching name"
+ )
return
@attr(tags=["advanced", "basic"], required_hardware="false")
def test_08_list_vm_by_zone(self):
- """
- @Desc: Test List VM by Zone.
+ """
+ @Desc: Test List VM by Zone.
This test case is applicable for a setup having multiple zones.
@Steps:
Step1: Listing all the zones
@@ -966,7 +996,8 @@ class TestListInstances(cloudstackTestCase):
Step6: Deploying a VM
Step7: Listing all the VMs for a user again for matching zone
Step8: Verifying that the size of the list is 1
- Step9: Verifying that the details of the Listed VM are same as the VM deployed in Step6
+ Step9: Verifying that the details of the Listed VM are same
+ as the VM deployed in Step6
Step10: Listing all the VMs for a user again for non-matching zone
Step11: Verifying that the size of the list is 0
"""
@@ -974,10 +1005,10 @@ class TestListInstances(cloudstackTestCase):
zones_list = Zone.list(self.apiClient)
status = validateList(zones_list)
self.assertEquals(
- PASS,
- status[0],
- "zones not available in the given setup"
- )
+ PASS,
+ status[0],
+ "zones not available in the given setup"
+ )
current_zone = self.services["virtual_machine"]["zoneid"]
current_template = self.services["virtual_machine"]["template"]
# Checking if there are multiple zones in the setup.
@@ -986,114 +1017,114 @@ class TestListInstances(cloudstackTestCase):
else:
# Getting the template available under the zone
template = get_template(
- self.apiClient,
- zones_list[0].id,
- self.services["ostype"]
- )
+ self.apiClient,
+ zones_list[0].id,
+ self.services["ostype"]
+ )
self.assertIsNotNone(
- template,
- "Template not found for zone"
- )
+ template,
+ "Template not found for zone"
+ )
self.services["virtual_machine"]["zoneid"] = zones_list[0].id
self.services["virtual_machine"]["template"] = template.id
# Listing all the VM's for a User
list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ zoneid=zones_list[0].id
+ )
self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
+ list_vms_before,
+ "Virtual Machine already exists for newly created user"
+ )
# Deploying a VM
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
+ vm_created,
+ "VM creation failed"
+ )
# Listing all the VMs for a user again for matching zone
list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ zoneid=zones_list[0].id
+ )
status = validateList(list_vms_after)
self.assertEquals(
- PASS,
- status[0],
- "VM creation failed"
- )
+ PASS,
+ status[0],
+ "VM creation failed"
+ )
# Verifying that the size of the list is 1
self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
+ 1,
+ len(list_vms_after),
+ "VM list count is not matching"
+ )
listed_vm = list_vms_after[0]
- # Verifying that the details of the Listed VM are same as the VM deployed above
+ # Verifying that the details of the Listed VM are
+ # same as the VM deployed above
# Creating expected and actual values dictionaries
expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":vm_created.state,
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
+ "id": vm_created.id,
+ "name": vm_created.name,
+ "displayname": vm_created.displayname,
+ "state": vm_created.state,
+ "zoneid": vm_created.zoneid,
+ "account": vm_created.account,
+ "template": vm_created.templateid
+ }
actual_dict = {
- "id":listed_vm.id,
- "name":listed_vm.name,
- "displayname":listed_vm.displayname,
- "state":listed_vm.state,
- "zoneid":listed_vm.zoneid,
- "account":listed_vm.account,
- "template":listed_vm.templateid
- }
+ "id": listed_vm.id,
+ "name": listed_vm.name,
+ "displayname": listed_vm.displayname,
+ "state": listed_vm.state,
+ "zoneid": listed_vm.zoneid,
+ "account": listed_vm.account,
+ "template": listed_vm.templateid
+ }
list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
+ expected_dict,
+ actual_dict
+ )
self.assertEqual(
- True,
- list_vm_status,
- "Listed VM by Id details are not as expected"
- )
+ True,
+ list_vm_status,
+ "Listed VM by Id details are not as expected"
+ )
# Listing all the VMs for a user again for non-matching zone
list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[1].id
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ zoneid=zones_list[1].id
+ )
self.assertIsNone(
- list_vms,
- "VM's listed for non matching zone"
- )
+ list_vms,
+ "VM's listed for non matching zone"
+ )
self.services["virtual_machine"]["zoneid"] = current_zone
self.services["virtual_machine"]["template"] = current_template
return
@attr(tags=["advanced", "basic"], required_hardware="false")
def test_09_list_vm_by_zone_name(self):
- """
- @Desc: Test List VM by Zone.
+ """
+ @Desc: Test List VM by Zone.
This test case is applicable for a setup having multiple zones.
@Steps:
Step1: Listing all the zones
@@ -1105,22 +1136,26 @@ class TestListInstances(cloudstackTestCase):
Step6: Deploying a VM
Step7: Listing all the VMs for a user again
Step8: Verifying that list size is increased by 1
- Step9: Listing the VM by specifying name of VM created in step6 and matching zone (matching name and zone)
+ Step9: Listing the VM by specifying name of VM created in step6
+ and matching zone (matching name and zone)
Step10: Verifying that the size of the list is 1
- Step11: Verifying that the details of the listed VM are same as the VM created in step3
- Step12: Listing the VM by specifying name of VM created in step6 and non matching zone (non matching zone)
+ Step11: Verifying that the details of the listed VM are same
+ as the VM created in step3
+ Step12: Listing the VM by specifying name of VM created in step6
+ and non matching zone (non matching zone)
Step13: Verifying that the size of the list is 0
- Step14: Listing the VM by specifying non matching name and matching zone (non matching name)
+ Step14: Listing the VM by specifying non matching name and
+ matching zone (non matching name)
Step15: Verifying that the size of the list is 0
"""
# Listing all the zones available
zones_list = Zone.list(self.apiClient)
status = validateList(zones_list)
self.assertEquals(
- PASS,
- status[0],
- "zones not available in the given setup"
- )
+ PASS,
+ status[0],
+ "zones not available in the given setup"
+ )
current_zone = self.services["virtual_machine"]["zoneid"]
current_template = self.services["virtual_machine"]["template"]
# Checking if there are multiple zones in the setup.
@@ -1129,343 +1164,353 @@ class TestListInstances(cloudstackTestCase):
else:
# Getting the template available under the zone
template = get_template(
- self.apiClient,
- zones_list[0].id,
- self.services["ostype"]
- )
+ self.apiClient,
+ zones_list[0].id,
+ self.services["ostype"]
+ )
self.assertIsNotNone(
- template,
- "Template not found for zone"
- )
+ template,
+ "Template not found for zone"
+ )
self.services["virtual_machine"]["zoneid"] = zones_list[0].id
self.services["virtual_machine"]["template"] = template.id
# Listing all the VM's for a User
list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id,
- account=self.account.name
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ zoneid=zones_list[0].id,
+ account=self.account.name
+ )
self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
+ list_vms_before,
+ "Virtual Machine already exists for newly created user"
+ )
# Deploying a VM
vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
+ self.userapiclient,
+ self.services["virtual_machine"],
+ accountid=self.account.name,
+ domainid=self.account.domainid,
+ serviceofferingid=self.service_offering.id,
+ )
self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
+ vm_created,
+ "VM creation failed"
+ )
# Listing all the VMs for a user again for matching zone
list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id,
- account=self.account.name
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ zoneid=zones_list[0].id,
+ account=self.account.name
+ )
status = validateList(list_vms_after)
self.assertEquals(
- PASS,
- status[0],
- "VM creation failed"
- )
+ PASS,
+ status[0],
+ "VM creation failed"
+ )
# Verifying that the size of the list is 1
self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
- # Listing the VM by specifying name of VM created in above and matching zone
+ 1,
+ len(list_vms_after),
+ "VM list count is not matching"
+ )
+ # Listing the VM by specifying name of VM created in above and
+ # matching zone
list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id,
- name=vm_created.name
- )
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"],
+ domainid=self.account.domainid,
+ zoneid=zones_list[0].id,
+ name=vm_created.name
+ )
status = validateList(list_vms)
self.assertEquals(
- PASS,
- status[0],
- "Listing VM's by name and zone failed"
- )
+ PASS,
+ status[0],
+ "Listing VM's by name and zone failed"
+ )
# Verifying Verifying that the size of the list is 1
self.assertEquals(
- 1,
- len(list_vms),
- "Count of listed VM's by name and zone is not as expected"
- )
+ 1,
+ len(list_vms),
+ "Count of listed VM's by name and zone is not as expected"
+ )
listed_vm = list_vms[0]
- # Verifying that the details of the Listed VM are same as the VM deployed above
+ # Verifying that the details of the Listed VM are same
+ # as the VM deployed above
# Creating expected and actual values dictionaries
expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":vm_created.state,
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
+ "id": vm_created.id,
+ "name": vm_created.name,
+ "displayname": vm_created.displayname,
+ "state": vm_created.state,
+ "zoneid": vm_created.zoneid,
+ "account": vm_created.account,
+ "template": vm_created.templateid
+ }
actual_dict = {
- "id":listed_vm.id,
- "name":listed_vm.name,
- "displayname":listed_vm.displayname,
- "state":listed_vm.state,
- "zoneid":listed_vm.zoneid,
- "account":listed_vm.account,
- "template":listed_vm.templateid
- }
+ "id": listed_vm.id,
+ "name": listed_vm.name,
+ "displayname": listed_vm.displayname,
+ "state": listed_vm.state,
+ "zoneid": listed_vm.zoneid,
+ "account": listed_vm.account,
+ "template": listed_vm
<TRUNCATED>