cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gir...@apache.org
Subject [6/7] Revert "CLOUDSTACK-6282 - Divided test_escalations.py into individual files based on functionality and added automed tests for Public IP Addresses"
Date Mon, 19 May 2014 12:45:04 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/d43d28ee/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
deleted file mode 100644
index 9e040db..0000000
--- a/test/integration/component/test_escalations_instances.py
+++ /dev/null
@@ -1,3448 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-#Import Local Modules
-from marvin.cloudstackTestCase import cloudstackTestCase
-from marvin.cloudstackAPI import (createVolume,
-                                  createTemplate)
-from marvin.lib.base import (Volume,
-                             Iso,
-                             VirtualMachine,
-                             Template,
-                             Snapshot,
-                             SecurityGroup,
-                             Account,
-                             Zone,
-                             Network,
-                             NetworkOffering,
-                             DiskOffering,
-                             ServiceOffering,
-                             VmSnapshot,
-                             SnapshotPolicy,
-                             SSHKeyPair,
-                             Resources,
-                             Configurations,
-                             VpnCustomerGateway,
-                             Hypervisor,
-                             VpcOffering,
-                             VPC,
-                             NetworkACL)
-from marvin.lib.common import (get_zone,
-                               get_domain,
-                               get_template,
-                               list_os_types)
-from marvin.lib.utils import (validateList,
-                              cleanup_resources,
-                              random_gen)
-from marvin.codes import (PASS, FAIL, EMPTY_LIST)
-from nose.plugins.attrib import attr
-import time
-
-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.testClient.getZoneForTests())
-            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.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._cleanup.append(cls.service_offering)
-            cls._cleanup.append(cls.disk_offering)
-        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 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"
-              

<TRUNCATED>

Mime
View raw message