cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tall...@apache.org
Subject [2/3] 0001-JiraId-CLOUDSTACK-6282.patch Added automated tests for Instances API calls to test_escalations.py file and added utility functions to base.py file
Date Thu, 24 Apr 2014 07:04:42 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/2e95b5b7/test/integration/component/test_escalations.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_escalations.py b/test/integration/component/test_escalations.py
index e132fb0d..c3e3066 100644
--- a/test/integration/component/test_escalations.py
+++ b/test/integration/component/test_escalations.py
@@ -76,7 +76,7 @@ class TestVolumes(cloudstackTestCase):
         # Getting authentication for user in newly created Account
         cls.user = cls.account.user[0]
 
-        cls.userapiclient = cls.testClient.getUserApiClient(cls.user.username, cls.domain.id)
+        cls.userapiclient = cls.testClient.getUserApiClient(cls.user.username, cls.domain.name)
 
         # Creating Virtual Machine
         cls.virtual_machine = VirtualMachine.create(
@@ -519,10 +519,8 @@ class TestVolumes(cloudstackTestCase):
                 large_disk_offering_exists = True
                 break
 
-        # Setting the new disk size to be greater than current disk size by 1GB
-        new_size = (volume_created.size/(1024*1024*1024)) + 1
-
         if large_disk_offering_exists == False:
+            new_size = (volume_created.size/(1024*1024*1024)) + 1
             self.services["disk_offering"]["disksize"] = new_size
             new_disk_offering = DiskOffering.create(
                                                     self.apiClient,
@@ -530,6 +528,8 @@ class TestVolumes(cloudstackTestCase):
                                                     )
             if new_disk_offering is not None:
                 self.cleanup.append(new_disk_offering)
+        else:
+            new_size = new_disk_offering.disksize
 
         # Resizing data volume
         resized_volume = volume_created.resize(
@@ -1702,3 +1702,4043 @@ class TestVolumes(cloudstackTestCase):
                           "upload volume failed"
                           )
         return
+
+class TestListInstances(cloudstackTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        try:
+            cls._cleanup = []        
+            cls.testClient = super(TestListInstances, cls).getClsTestClient()
+            cls.api_client = cls.testClient.getApiClient()
+            cls.services = cls.testClient.getParsedTestDataConfig()
+
+            # Get Domain, Zone, Template
+            cls.domain = get_domain(cls.api_client)
+            cls.zone = get_zone(cls.api_client)
+            cls.template = get_template(
+                                        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["disk_offering"]["storagetype"] = 'local'
+            else:
+                cls.storagetype = 'shared'
+                cls.services["service_offerings"]["tiny"]["storagetype"] = 'shared'
+                cls.services["disk_offering"]["storagetype"] = 'shared'
+
+            cls.services['mode'] = cls.zone.networktype
+            cls.services["virtual_machine"]["hypervisor"] = cls.testClient.getHypervisorInfo()
+            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
+            cls.services["virtual_machine"]["template"] = cls.template.id
+            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._cleanup.append(cls.disk_offering)
+            cls.service_offering = ServiceOffering.create(
+                                                          cls.api_client,
+                                                          cls.services["service_offerings"]["tiny"]
+                                                          )
+            cls._cleanup.append(cls.service_offering)
+            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)
+        except Exception as e:
+            cls.tearDownClass()
+            raise Exception("Warning: Exception in setup : %s" % e)
+        return
+
+    def setUp(self):
+
+        self.apiClient = self.testClient.getApiClient()
+        self.cleanup = []
+
+    def tearDown(self):
+        #Clean up, terminate the created resources
+        cleanup_resources(self.apiClient, self.cleanup)
+        return
+
+    @classmethod
+    def tearDownClass(cls):
+        try:
+            cleanup_resources(cls.api_client, cls._cleanup)
+        except Exception as e:
+            raise Exception("Warning: Exception during cleanup : %s" % e)
+
+        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.
+               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
+               If not making return flag to False
+        Step4: returning the return flag after all the values are verified
+        """
+        return_flag = True
+
+        if len(expected_vals) != len(actual_vals):
+            return False
+
+        keys = expected_vals.keys()
+        for i in range(0, len(expected_vals)):
+            exp_val = expected_vals[keys[i]]
+            act_val = actual_vals[keys[i]]
+            if exp_val == act_val:
+                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
+                                                                                          ))
+        return return_flag
+
+    @attr(tags=["advanced", "basic", "selfservice"])
+    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
+        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)
+        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
+        Step11: Listing for the volumes on page 2
+        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"])
+
+        # 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    
+        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.assertIsNotNone(
+                                 vm_created,
+                                 "VM creation failed"
+                                 )
+            if(i < (self.services["pagesize"])):
+                self.cleanup.append(vm_created)
+
+            self.assertEqual(
+                             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"])
+        status = validateList(list_instances_after)
+        self.assertEquals(
+                          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"
+                         )
+
+        # 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
+                                                   )
+        status = validateList(list_instances_page1)
+        self.assertEquals(
+                          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"
+                         )
+
+        # 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
+                                                   )
+        status = validateList(list_instances_page2)
+        self.assertEquals(
+                          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"
+                         )
+        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"
+                                 )
+
+        # Deleting a single VM
+        VirtualMachine.delete(vm_created, self.userapiclient)
+
+        # 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
+                                                     )
+        # verifying that VM does not exists on page 2
+        self.assertEqual(
+                        list_instance_response,
+                        None,
+                        "VM was not deleted"
+                        )
+        return
+ 
+    @attr(tags=["advanced", "basic", "selfservice"])
+    def test_02_list_Running_vm(self):
+        """  
+        @Desc: Test List Running VM's
+        @Steps:
+        Step1: Listing all the Running VMs for a user
+        Step2: Verifying that the size of the list is 0
+        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
+        """
+        # 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.assertIsNone(
+                          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.assertIsNotNone(
+                             vm_created,
+                             "VM creation failed"
+                             )
+        self.cleanup.append(vm_created)
+        # 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"
+                                                      )
+        status = validateList(list_running_vms_after)
+        self.assertEquals(
+                          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"
+                          )
+        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
+                         }
+        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
+                       }
+        running_vm_status = self.__verify_values(
+                                                  expected_dict,
+                                                  actual_dict
+                                                  )
+        self.assertEqual(
+                         True,
+                         running_vm_status,
+                         "Listed Running VM details are not as expected"
+                         )
+        return
+
+    @attr(tags=["advanced", "basic", "selfservice"])
+    def test_03_list_Stopped_vm(self):
+        """  
+        @Desc: Test List Stopped VM's
+        @Steps:
+        Step1: Listing all the Stopped VMs for a user
+        Step2: Verifying that the size of the list is 0
+        Step3: Deploying a VM
+        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
+        """
+        # 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.assertIsNone(
+                           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.assertIsNotNone(
+                             vm_created,
+                             "VM creation failed"
+                             )
+        self.cleanup.append(vm_created)
+        # 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"
+                                                      )
+        status = validateList(list_stopped_vms_after)
+        self.assertEquals(
+                          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"
+                          )
+        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
+                         }
+        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
+                       }
+        stopped_vm_status = self.__verify_values(
+                                                  expected_dict,
+                                                  actual_dict
+                                                  )
+        self.assertEqual(
+                         True,
+                         stopped_vm_status,
+                         "Listed Stopped VM details are not as expected"
+                         )
+        return
+
+    @attr(tags=["advanced", "basic", "selfservice"])
+    def test_04_list_Destroyed_vm(self):
+        """  
+        @Desc: Test List Destroyed VM's
+        @Steps:
+        Step1: Listing all the Destroyed VMs for a user
+        Step2: Verifying that the size of the list is 0
+        Step3: Deploying a VM
+        Step4: Destroyed the VM deployed in step3
+        Step5: Listing all the Destroyed VMs for a user again
+        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
+        """
+        # 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.assertIsNone(
+                           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.assertIsNotNone(
+                             vm_created,
+                             "VM creation failed"
+                             )
+        # Destroying the VM
+        VirtualMachine.delete(vm_created, self.userapiclient)
+        # 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.assertIsNone(
+                          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
+                                                       )
+        status = validateList(list_destroyed_vms_admin)
+        self.assertEquals(
+                          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"
+                          )
+        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
+                         }
+        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
+                       }
+        destroyed_vm_status = self.__verify_values(
+                                                  expected_dict,
+                                                  actual_dict
+                                                  )
+        self.assertEqual(
+                         True,
+                         destroyed_vm_status,
+                         "Listed Destroyed VM details are not as expected"
+                         )
+        return
+
+    @attr(tags=["advanced", "basic", "selfservice"])
+    def test_05_list_vm_by_id(self):
+        """  
+        @Desc: Test List VM by Id
+        @Steps:
+        Step1: Listing all the VMs for a user
+        Step2: Verifying that the size of the list is 0
+        Step3: Deploying a VM
+        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
+        """
+        # 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.assertIsNone(
+                           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.assertIsNotNone(
+                             vm_created,
+                             "VM creation failed"
+                             )
+        self.cleanup.append(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,
+                                             account=self.account.name
+                                             )
+        status = validateList(list_vms_after)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "Listing of VM after creation failed"
+                          )
+        self.assertEquals(
+                          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
+                                           )
+        status = validateList(list_vm_byid)
+        self.assertEquals(
+                          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
+                         }
+        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
+                       }
+        list_vm_status = self.__verify_values(
+                                              expected_dict,
+                                              actual_dict
+                                              )
+        self.assertEqual(
+                         True,
+                         list_vm_status,
+                         "Listed VM by Id details are not as expected"
+                         )
+        return
+
+    @attr(tags=["advanced", "basic", "selfservice"])
+    def test_06_list_vm_by_name(self):
+        """  
+        @Desc: Test List VM's by Name
+        @Steps:
+        Step1: Listing all the VMs for a user
+        Step2: Verifying that the size of the list is 0
+        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
+        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
+        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.assertIsNone(
+                           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.assertIsNotNone(
+                                 vm_created,
+                                 "VM creation failed"
+                                 )
+            self.cleanup.append(vm_created)
+            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,
+                                             )
+        status = validateList(list_vms_after)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "VM's creation failed"
+                          )
+        self.assertEquals(
+                          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
+                                                 )
+        status = validateList(list_vm_byfullname)
+        self.assertEquals(
+                          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
+        #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
+                         }
+        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
+                       }
+        list_vm_status = self.__verify_values(
+                                              expected_dict,
+                                              actual_dict
+                                              )
+        self.assertEqual(
+                         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]
+                                                 )
+        status = validateList(list_vm_bypartialname)
+        self.assertEquals(
+                          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"
+                          )
+        return
+
+    @attr(tags=["advanced", "basic", "selfservice"])
+    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
+        Step2: Verifying that the size of the list is 0
+        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)
+        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)
+        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)
+        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.assertIsNone(
+                           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.assertIsNotNone(
+                             vm_created,
+                             "VM creation failed"
+                             )
+        self.cleanup.append(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,
+                                             )
+        status = validateList(list_vms_after)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "VM's creation failed"
+                          )
+        self.assertEquals(
+                          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"
+                                              )
+        status = validateList(list_running_vm)
+        self.assertEquals(
+                          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
+        #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
+                         }
+        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
+                       }
+        list_vm_status = self.__verify_values(
+                                              expected_dict,
+                                              actual_dict
+                                              )
+        self.assertEqual(
+                         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.assertIsNone(
+                          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.assertIsNone(
+                          list_running_vm,
+                          "Listed VM with non matching name"
+                          )
+        return
+
+    @attr(tags=["advanced", "basic", "selfservice"])
+    def test_08_list_vm_by_zone(self):
+        """  
+        @Desc: Test List VM by Zone. 
+        This test case is applicable for a setup having multiple zones.
+        @Steps:
+        Step1: Listing all the zones
+        Step2: Checking if there are multiple zones in the setup.
+               Continuing below steps only if there are multiple zones
+        Step3: Listing template for zone
+        Step4: Listing all the VMs for a user
+        Step5: Verifying that the size of the list is 0
+        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
+        Step10: Listing all the VMs for a user again for non-matching zone
+        Step11: 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"
+                          )
+        current_zone = self.services["virtual_machine"]["zoneid"]
+        current_template = self.services["virtual_machine"]["template"]
+        # Checking if there are multiple zones in the setup.
+        if not len(zones_list) > 1:
+            self.debug("Setup is not having multiple zones")
+        else:
+            # Getting the template available under the zone
+            template = get_template(
+                                    self.apiClient,
+                                    zones_list[0].id,
+                                    self.services["ostype"]
+                                    )
+            self.assertIsNotNone(
+                                 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.assertIsNone(
+                               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.assertIsNotNone(
+                                 vm_created,
+                                 "VM creation failed"
+                                 )
+            self.cleanup.append(vm_created)
+            # 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
+                                                 )
+            status = validateList(list_vms_after)
+            self.assertEquals(
+                              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"
+                              )
+            listed_vm = list_vms_after[0]
+            # 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
+                               }
+            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
+                               }
+            list_vm_status = self.__verify_values(
+                                                  expected_dict,
+                                                  actual_dict
+                                                  )
+            self.assertEqual(
+                             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.assertIsNone(
+                              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", "selfservice"])
+    def test_09_list_vm_by_zone_name(self):
+        """  
+        @Desc: Test List VM by Zone. 
+        This test case is applicable for a setup having multiple zones.
+        @Steps:
+        Step1: Listing all the zones
+        Step2: Checking if there are multiple zones in the setup.
+               Continuing below steps only if there are multiple zones
+        Step3: Listing template for zone
+        Step4: Listing all the VMs for a user
+        Step5: Verifying that the size of the list is 0
+        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)
+        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)
+        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)
+        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"
+                          )
+        current_zone = self.services["virtual_machine"]["zoneid"]
+        current_template = self.services["virtual_machine"]["template"]
+        # Checking if there are multiple zones in the setup.
+        if not len(zones_list) > 1:
+            self.debug("Setup is not having multiple Zones")
+        else:
+            # Getting the template available under the zone
+            template = get_template(
+                                    self.apiClient,
+                                    zones_list[0].id,
+                                    self.services["ostype"]
+                                    )
+            self.assertIsNotNone(
+                                 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.assertIsNone(
+                               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.assertIsNotNone(
+                                 vm_created,
+                                 "VM creation failed"
+                                 )
+            self.cleanup.append(vm_created)
+            # 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
+                                                 )
+            status = validateList(list_vms_after)
+            self.assertEquals(
+                              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
+            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
+                                           )
+            status = validateList(list_vms)
+            self.assertEquals(
+                              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"
+                              )
+            listed_vm = list_vms[0]
+            # 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
+                               }
+            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
+                               }
+            list_vm_status = self.__verify_values(
+                                                  expected_dict,
+                                                  actual_dict
+                                                  )
+            self.assertEqual(
+                             True,
+                             list_vm_status,
+                             "Listed VM by Id details are not as expected"
+                             )
+            # Listing the VM by specifying name of VM created in step3 and 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,
+                                           name=vm_created.name
+                                           )
+            self.assertIsNone(
+                              list_vms,
+                              "VM's listed for non matching zone"
+                              )
+            # Listing the VM by specifying non matching name of VM 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="name"
+                                           )
+            self.assertIsNone(
+                              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", "selfservice"])
+    def test_10_list_vm_by_zone_name_state(self):
+        """  
+        @Desc: Test List VM by Zone. 
+        @Steps:
+        Step1: Listing all the VMs for a user
+        Step2: Verifying that the size of the list is 0
+        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 matching zone and state as Running
+        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 matching zone and state as Stopped
+        Step10: Verifying that the size of the list is 0
+        Step11: Listing the VM by name, Zone and account
+        Step12: Verifying that the size of the list is 1
+        Step13: Verifying that the details of the listed VM are same as the VM created 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,
+                                              zoneid=self.zone.id,
+                                              account=self.account.name
+                                              )
+        self.assertIsNone(
+                           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.assertIsNotNone(
+                             vm_created,
+                             "VM creation failed"
+                             )
+        self.cleanup.append(vm_created)
+        # 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=self.zone.id,
+                                             account=self.account.name
+                                             )
+        status = validateList(list_vms_after)
+        self.assertEquals(
+                          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 step3 and matching zone and state as Running
+        list_vms = VirtualMachine.list(
+                                       self.userapiclient,
+                                       listall=self.services["listall"],
+                                       page=1,
+                                       pagesize=self.services["pagesize"],
+                                       domainid=self.account.domainid,
+                                       zoneid=self.zone.id,
+                                       name=vm_created.name,
+                                       state="Running"
+                                       )
+        status = validateList(list_vms)
+        self.assertEquals(
+                          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, zone and state is not as expected"
+                          )
+        listed_vm = list_vms[0]
+        # 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
+                       }
+        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
+                       }
+        list_vm_status = self.__verify_values(
+                                              expected_dict,
+                                              actual_dict
+                                              )
+        self.assertEqual(
+                         True,
+                         list_vm_status,
+                         "Listed VM by Id details are not as expected"
+                         )
+        # Listing the VM by specifying name of VM created in step3, zone and State as Stopped
+        list_vms = VirtualMachine.list(
+                                       self.userapiclient,
+                                       listall=self.services["listall"],
+                                       page=1,
+                                       pagesize=self.services["pagesize"],
+                                       domainid=self.account.domainid,
+                                       zoneid=self.zone.id,
+                                       name=vm_created.name,
+                                       state="Stopped"
+                                       )
+        self.assertIsNone(
+                          list_vms,
+                          "VM's listed for non matching zone"
+                          )
+        # Listing the VM by name, zone and account
+        list_vms = VirtualMachine.list(
+                                       self.userapiclient,
+                                       listall=self.services["listall"],
+                                       page=1,
+                                       pagesize=self.services["pagesize"],
+                                       domainid=self.account.domainid,
+                                       zoneid=self.zone.id,
+                                       name=vm_created.name,
+                                       account=self.account.name
+                                       )
+        status = validateList(list_vms)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "Listing VM's by name, account 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, zone and account is not as expected"
+                          )
+        listed_vm = list_vms[0]
+        # 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
+                         }
+        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
+                       }
+        list_vm_status = self.__verify_values(
+                                              expected_dict,
+                                              actual_dict
+                                              )
+        self.assertEqual(
+                         True,
+                         list_vm_status,
+                         "Listed VM by Id details are not as expected"
+                         )
+        return
+
+    @attr(tags=["advanced", "basic", "provisioning"])
+    def test_11_register_reset_vm_sshkey(self):
+        """  
+        @Desc: Test to verify registering and reset of SSH Key for VM
+        @Steps:
+        Step1: Deploying a VM
+        Step2: Stopping the VM deployed in step1
+        Step3: Listing all the SSH Key pairs
+        Step4: Registering a SSH Key pair
+        Step5: Listing all the SSh Key pairs again
+        Step6: Verifying that the key pairs list is increased by 1
+        Step7: Resetting the VM SSH Key to the key pair registered in step4
+        Step8: Verifying that the registered SSH Key pair is set to the VM
+        """
+        # Listing all the VM's for a User
+        list_vms_before = VirtualMachine.list(
+                                              self.userapiclient,
+                                              listall=self.services["listall"],
+                                              )
+        self.assertIsNone(
+                           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.assertIsNotNone(
+                             vm_created,
+                             "VM creation failed"
+                             )
+        self.cleanup.append(vm_created)
+        # Listing all the VMs for a user again
+        list_vms_after = VirtualMachine.list(
+                                             self.userapiclient,
+                                             listall=self.services["listall"],
+                                             )
+        status = validateList(list_vms_after)
+        self.assertEquals(
+                          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"
+                          )
+        # Stopping the VM deployed above
+        vm_created.stop(
+                        self.userapiclient,
+                        forced=True
+                        )
+        # Listing VM details
+        list_vm = VirtualMachine.list(
+                                      self.userapiclient,
+                                      id=vm_created.id
+                                     )
+        status = validateList(list_vm)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "Listing of VM failed"
+                          )
+        self.assertEquals(
+                          "Stopped",
+                          list_vm[0].state,
+                          "Stopped VM is not in stopped state"
+                          )
+        # Listing all the SSH Key pairs
+        list_keypairs_before = SSHKeyPair.list(
+                                               self.userapiclient
+                                               )
+        list_keypairs_before_size = 0
+        if list_keypairs_before is not None:
+            list_keypairs_before_size = len(list_keypairs_before)
+
+        # Registering new Key pair
+        new_keypair = SSHKeyPair.register(
+                                          self.userapiclient,
+                                          name="keypair1",
+                                          publickey="ssh-rsa: e6:9a:1e:b5:98:75:88:5d:56:bc:92:7b:43:48:05:b2"
+                                          )
+        self.assertIsNotNone(
+                             new_keypair,
+                             "New Key pair generation failed"
+                             )
+        self.assertEquals(
+                          "keypair1",
+                          new_keypair.name,
+                          "Key Pair not created with given name"
+                          )
+        # Listing all the SSH Key pairs again
+        list_keypairs_after = SSHKeyPair.list(
+                                              self.userapiclient
+                                              )
+        status = validateList(list_keypairs_after)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "Listing of Key pairs failed"
+                          )
+        # Verifying that list size is increased by 1
+        self.assertEquals(
+                          list_keypairs_before_size + 1,
+                          len(list_keypairs_after),
+                          "List count is not matching"
+                          )
+        # Resetting the VM SSH key to the Key pair created above
+        vm_created.resetSshKey(
+                               self.userapiclient,
+                               keypair=new_keypair.name
+                               )
+        # Listing VM details again
+        list_vm = VirtualMachine.list(
+                                      self.userapiclient,
+                                      id=vm_created.id
+                                     )
+        status = validateList(list_vm)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "Listing of VM failed"
+                          )
+        self.assertEquals(
+                          1,
+                          len(list_vm),
+                          "VMs list is not as expected"
+                          )
+        # Verifying that VM's SSH keypair is set to newly created keypair
+        self.assertEquals(
+                          new_keypair.name,
+                          list_vm[0].keypair,
+                          "VM is not set to newly created SSH Key pair"
+                          )
+        return
+
+    @attr(tags=["advanced", "provisioning"])
+    def test_12_vm_nics(self):
+        """  
+        @Desc: Test to verify Nics for a VM
+        @Steps:
+        Step1: Deploying a VM
+        Step2: Listing all the Networks
+        Step3: Verifying that the list size is 1
+        Step4: Creating 1 network
+        Step5: Listing all the networks again
+        Step6: Verifying that the list size is 2
+        Step7: Verifying that VM deployed in step1 has only 1 nic 
+                and it is same as network listed in step3
+        Step8: Adding the networks created in step4 to VM deployed in step1
+        Step9: Verifying that VM deployed in step1 has 2 nics
+        Step10: Verifying that isdefault is set to true for only 1 nic
+        Step11: Verifying that isdefault is set to true for the Network created when deployed a VM
+        Step12: Making the nic created in step4 as default nic
+        Step13: Verifying that isdefault is set to true for only 1 nic
+        Step14: Verifying that the isdefault is set to true for the nic created in step4
+        Step15: Removing the non-default nic from VM
+        Step16: Verifying that VM deployed in step1 has only 1 nic
+        """
+        # Listing all the VM's for a User
+        list_vms_before = VirtualMachine.list(
+                                              self.userapiclient,
+                                              listall=self.services["listall"],
+                                              )
+        self.assertIsNone(
+                           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.assertIsNotNone(
+                             vm_created,
+                             "VM creation failed"
+                             )
+        self.cleanup.append(vm_created)
+        # Listing all the VMs for a user again
+        list_vms_after = VirtualMachine.list(
+                                             self.userapiclient,
+                                             listall=self.services["listall"],
+                                             )
+        status = validateList(list_vms_after)
+        self.assertEquals(
+                          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 all the networks before
+        list_network_before = Network.list(
+                                           self.userapiclient,
+                                           isdefault="true",
+                                           zoneid=self.zone.id,
+                                           account=self.account.name,
+                                           domainid=self.domain.id
+                                           )
+        status = validateList(list_network_before)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "Default Network not created when deploying a VM"
+                          )
+        # Verifying that only 1 network is created while deploying a VM
+        self.assertEquals(
+                          1,
+                          len(list_network_before),
+                          "More than 1 default network exists"
+                          )
+        network1 = list_network_before[0]
+        # Listing Network Offerings
+        network_offerings_list = NetworkOffering.list(
+                                                      self.apiClient,
+                                                      forvpc="false",
+                                                      guestiptype="Isolated",
+                                                      state="Enabled",
+                                                      supportedservices="SourceNat",
+                                                      zoneid=self.zone.id
+                                                      )
+        self.assertIsNotNone(
+                             network_offerings_list,
+                             "Isolated Network Offerings with sourceNat enabled are not found"
+                             )
+        # Creating one more network
+        network2 = Network.create(
+                                  self.userapiclient,
+                                  self.services["network"],
+                                  accountid=self.account.name,
+                                  domainid=self.domain.id,
+                                  networkofferingid=network_offerings_list[0].id,
+                                  zoneid=self.zone.id
+                                  )
+        self.assertIsNotNone(
+                             network2,
+                             "Network creation failed"
+                             )
+        self.cleanup.append(network2)
+        # Listing all the networks again
+        list_network_after = Network.list(
+                                          self.userapiclient,
+                                          zoneid=self.zone.id,
+                                          account=self.account.name,
+                                          domainid=self.domain.id
+                                          )
+        status = validateList(list_network_after)
+        self.assertEquals(
+                          PASS,
+                          status[0],
+                          "List of Networks failed"
+                          )
+        # Verifying that list size is 2
+        self.assertEquals(
+                          2,
+                          len(list_network_after),
+       

<TRUNCATED>

Mime
View raw message