def test_01_deploy_instance_with_is_volatile_offering(self): """ Test deploy an instance with service offerings with IsVolatile set. """ # Validate the following # 1. Service offerings were created successfully # 2. Vms were successfully deployed with the service offerings. self.debug("Checking if deployed VMs are in running state...") vms = VirtualMachine.list(self.apiclient, account=self.account.name, domainid=self.account.domainid, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "VM list validation failed due to %s" % vm_list_validation_result[2]) for vm in vms: self.debug("VM name: %s, VM state: %s" % (vm.name, vm.state)) self.debug("%s" % vm) self.assertEqual( vm.state, "Running", "Vm state should be running for each VM deployed") return
def test_01_deploy_instance_with_is_volatile_offering(self): """ Test deploy an instance with service offerings with IsVolatile set. """ # Validate the following # 1. Service offerings were created successfully # 2. Vms were successfully deployed with the service offerings. self.debug("Checking if deployed VMs are in running state...") vms = VirtualMachine.list( self.apiclient, account=self.account.name, domainid=self.account.domainid, listall=True ) vm_list_validation_result = validateList(vms) self.assertEqual(vm_list_validation_result[0], PASS, "VM list validation failed due to %s" % vm_list_validation_result[2]) for vm in vms: self.debug("VM name: %s, VM state: %s" % (vm.name, vm.state)) self.debug("%s" %vm) self.assertEqual( vm.state, "Running", "Vm state should be running for each VM deployed" ) return
def VerifyStaticNatForPublicIp(self, ipaddressid, natrulestatus): """ List public IP and verify that NAT rule status for the IP is as desired """ publiciplist = PublicIPAddress.list(self.apiclient, id=ipaddressid, listall=True) self.assertEqual(validateList(publiciplist)[0], PASS, "Public IP list validation failed") self.assertEqual(publiciplist[0].isstaticnat, natrulestatus, "isstaticnat should be %s, it is %s" % (natrulestatus, publiciplist[0].isstaticnat)) return
def verifyNetworkState(apiclient, networkid, state): """List networks and check if the network state matches the given state""" try: networks = Network.list(apiclient, id=networkid) except Exception as e: raise Exception("Failed while fetching network list with error: %s" % e) assert validateList(networks)[0] == PASS, "Networks list validation failed, list is %s" % networks assert str(networks[0].state).lower() == state, "network state should be %s, it is %s" % (state, networks[0].state) return
def verifyNetworkState(apiclient, networkid, state): """List networks and check if the network state matches the given state""" try: networks = Network.list(apiclient, id=networkid) except Exception as e: raise Exception("Failed while fetching network list with error: %s" % e) assert validateList(networks)[ 0] == PASS, "Networks list validation failed, list is %s" % networks assert str(networks[0].state).lower( ) == state, "network state should be %s, it is %s" % (state, networks[0].state) return
def is_public_ip_in_correct_state(apiclient, ipaddressid, state): """ Check if the given IP is in the correct state (given) and return True/False accordingly""" retriesCount = 10 while True: portableips = PublicIPAddress.list(apiclient, id=ipaddressid) assert validateList(portableips)[0] == PASS, "IPs list validation failed" if str(portableips[0].state).lower() == state: break elif retriesCount == 0: return False else: retriesCount -= 1 time.sleep(60) continue return True
def createNetwork(self, networkType): """Create a network of given type (isolated/shared/isolated in VPC)""" network = None if networkType == ISOLATED_NETWORK: try: network = Network.create(self.apiclient,self.services["isolated_network"], networkofferingid=self.isolated_network_offering.id, accountid=self.account.name,domainid=self.account.domainid, zoneid=self.zone.id) except Exception as e: self.fail("Isolated network creation failed because: %s" % e) elif networkType == SHARED_NETWORK: physical_network, vlan = get_free_vlan(self.api_client, self.zone.id) #create network using the shared network offering created self.services["shared_network"]["acltype"] = "domain" self.services["shared_network"]["vlan"] = vlan self.services["shared_network"]["networkofferingid"] = self.shared_network_offering.id self.services["shared_network"]["physicalnetworkid"] = physical_network.id self.services["shared_network"] = setSharedNetworkParams(self.services["shared_network"]) try: network = Network.create(self.api_client, self.services["shared_network"], networkofferingid=self.shared_network_offering.id, zoneid=self.zone.id) self.cleanup.append(network) except Exception as e: self.fail("Shared Network creation failed because: %s" % e) elif networkType == VPC_NETWORK: self.services["vpc"]["cidr"] = "10.1.1.1/16" self.debug("creating a VPC network in the account: %s" % self.account.name) vpc = VPC.create(self.apiclient, self.services["vpc"], vpcofferingid=self.vpc_off.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) vpcs = VPC.list(self.apiclient, id=vpc.id) self.assertEqual(validateList(vpcs)[0], PASS, "VPC list validation failed, vpc list is %s" % vpcs) network = Network.create(self.api_client,self.services["isolated_network"], networkofferingid=self.isolated_network_offering_vpc.id, accountid=self.account.name,domainid=self.account.domainid, zoneid=self.zone.id, vpcid=vpc.id, gateway="10.1.1.1", netmask="255.255.255.0") return network
def is_public_ip_in_correct_state(apiclient, ipaddressid, state): """ Check if the given IP is in the correct state (given) and return True/False accordingly""" retriesCount = 10 while True: portableips = PublicIPAddress.list(apiclient, id=ipaddressid) assert validateList( portableips)[0] == PASS, "IPs list validation failed" if str(portableips[0].state).lower() == state: break elif retriesCount == 0: return False else: retriesCount -= 1 time.sleep(60) continue return True
def verify_template_listing(self, template): retriesCount = int(self.services["retriesCount"]) template_list_validation_result = None while True: list_template_response = list_templates( self.apiclient, templatefilter=\ self.services["template"]["templatefilter"], id=template.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid ) template_list_validation_result = validateList(list_template_response) if template_list_validation_result[0] == PASS: break elif retriesCount == 0: self.fail("Failed to get the template list") # Sleep for 5 seconds and again continue the loop if retriesCount has not reached zero time.sleep(5) #Reduce the retriesCount until it becomes zero, when it reaches zero, exception is raised retriesCount = retriesCount - 1 template_response = template_list_validation_result[1] self.assertEqual( template_response.isready, True, "Check isready of newly created template Expected :True Got:%s" %template_response.isready ) return
def verify_template_listing(self, template): retriesCount = int(self.services["retriesCount"]) template_list_validation_result = None while True: list_template_response = list_templates( self.apiclient, templatefilter=\ self.services["template"]["templatefilter"], id=template.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid ) template_list_validation_result = validateList( list_template_response) if template_list_validation_result[0] == PASS: break elif retriesCount == 0: self.fail("Failed to get the template list") # Sleep for 5 seconds and again continue the loop if retriesCount has not reached zero time.sleep(5) #Reduce the retriesCount until it becomes zero, when it reaches zero, exception is raised retriesCount = retriesCount - 1 template_response = template_list_validation_result[1] self.assertEqual( template_response.isready, True, "Check isready of newly created template Expected :True Got:%s" % template_response.isready) return
def test_02_reboot_instance_with_is_volatile_offering(self): """ Test rebooting instances created with isVolatile service offerings """ # Validate the following # 1. Reboot the virtual machines. # 2. Validate the following # a. VM with created with isVolatile=True should have new Root disk but same IP # b. VM with created with isVolatile=False should have same Root disk and IP as before reboot self.debug("Rebooting the virtual machines in account: %s" % self.account.name) try: self.vm_with_reset.reboot(self.apiclient) self.vm_without_reset.reboot(self.apiclient) except Exception as e: self.fail("Failed to reboot the virtual machines, %s" % e) # Check if the the root disk was destroyed and recreated for isVolatile=True self.debug("Checking root disk of VM with isVolatile=True") vms = VirtualMachine.list(self.apiclient, id=self.vm_with_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "VM list validation failed due to %s" % vm_list_validation_result[2] ) vm_with_reset = vm_list_validation_result[1] vm_with_reset_root_disk_id = self.get_root_device_uuid_for_vm(vm_with_reset.id, vm_with_reset.rootdeviceid) self.assertNotEqual( self.vm_with_reset_root_disk_id, vm_with_reset_root_disk_id, "VM created with IsVolatile=True has same rootdeviceid : %s after reboot" % vm_with_reset_root_disk_id, ) # Make sure it has the same IP after reboot self.assertEqual( self.vm_with_reset.nic[0].ipaddress, vm_with_reset.nic[0].ipaddress, "VM created with IsVolatile=True doesn't have same ip after reboot. Got : %s Expected : %s" % (vm_with_reset.nic[0].ipaddress, self.vm_with_reset.nic[0].ipaddress), ) # Check if the the root disk was not destroyed for isVolatile=False self.debug("Checking root disk of VM with isVolatile=False") vms = VirtualMachine.list(self.apiclient, id=self.vm_without_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "list validation failed due to %s" % vm_list_validation_result[2] ) vm_without_reset = vm_list_validation_result[1] vm_without_reset_root_disk_id = self.get_root_device_uuid_for_vm( vm_without_reset.id, vm_without_reset.rootdeviceid ) self.assertEqual( self.vm_without_reset_root_disk_id, vm_without_reset_root_disk_id, "VM created with IsVolatile=False has different rootdeviceid after reboot Got: %s Expected : %s" % (vm_without_reset_root_disk_id, self.vm_without_reset_root_disk_id), ) # Make sure it has the same IP after reboot self.assertEqual( self.vm_without_reset.nic[0].ipaddress, vm_without_reset.nic[0].ipaddress, "VM created with IsVolatile=True doesn't have same ip after reboot. Got : %s Expected : %s" % (vm_without_reset.nic[0].ipaddress, self.vm_without_reset.nic[0].ipaddress), ) return
def create_vm(self, pfrule=False, egress_policy=True, RR=False): self.create_network_offering(egress_policy, RR) # Creating network using the network offering created self.debug("Creating network with network offering: %s" % self.network_offering.id) self.network = Network.create(self.apiclient, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=self.network_offering.id, zoneid=self.zone.id) self.cleanup_networks.append(self.network) self.debug("Created network with ID: %s" % self.network.id) self.debug("Deploying instance in the account: %s" % self.account.name) project = None try: self.virtual_machine = VirtualMachine.create(self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, mode=self.zone.networktype if pfrule else 'basic', networkids=[str(self.network.id)], projectid=project.id if project else None) self.cleanup_vms.append(self.virtual_machine) except Exception as e: self.fail("Virtual machine deployment failed with exception: %s" % e) self.debug("Deployed instance %s in account: %s" % (self.virtual_machine.id,self.account.name)) # Checking if VM is running or not, in case it is deployed in error state, test case fails self.vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id) self.assertEqual(validateList(self.vm_list)[0], PASS, "vm list validation failed, vm list is %s" % self.vm_list) self.assertEqual(str(self.vm_list[0].state).lower(),'running',"VM state should be running, it is %s" % self.vm_list[0].state) self.public_ip = PublicIPAddress.create( self.apiclient, accountid=self.account.name, zoneid=self.zone.id, domainid=self.account.domainid, networkid=self.network.id ) # Open up firewall port for SSH FireWallRule.create( self.apiclient, ipaddressid=self.public_ip.ipaddress.id, protocol=self.services["natrule"]["protocol"], cidrlist=['0.0.0.0/0'], startport=self.services["natrule"]["publicport"], endport=self.services["natrule"]["publicport"] ) self.debug("Creating NAT rule for VM ID: %s" % self.virtual_machine.id) #Create NAT rule NATRule.create( self.apiclient, self.virtual_machine, self.services["natrule"], self.public_ip.ipaddress.id ) return
def test_08_migrate_vm(self): """Test migrate VM """ # Validate the following # 1. Environment has enough hosts for migration # 2. DeployVM on suitable host (with another host in the cluster) # 3. Migrate the VM and assert migration successful suitable_hosts = None hosts = Host.list(self.apiclient, zoneid=self.zone.id, type='Routing') self.assertEqual( validateList(hosts)[0], PASS, "hosts list validation failed") if len(hosts) < 2: self.skipTest( "At least two hosts should be present in the zone for migration" ) hypervisor = str(get_hypervisor_type(self.apiclient)).lower() # For KVM, two hosts used for migration should be present in same cluster # For XenServer and VMware, migration is possible between hosts belonging to different clusters # with the help of XenMotion and Vmotion respectively. if hypervisor == "kvm": #identify suitable host clusters = [h.clusterid for h in hosts] #find hosts withe same clusterid clusters = [ cluster for index, cluster in enumerate(clusters) if clusters.count(cluster) > 1 ] if len(clusters) <= 1: self.skipTest( "In KVM, Live Migration needs two hosts within same cluster" ) suitable_hosts = [ host for host in hosts if host.clusterid == clusters[0] ] else: suitable_hosts = hosts target_host = suitable_hosts[0] migrate_host = suitable_hosts[1] #deploy VM on target host self.vm_to_migrate = VirtualMachine.create( self.api_client, self.services["small"], accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.small_offering.id, mode=self.services["mode"], hostid=target_host.id) self.debug("Migrating VM-ID: %s to Host: %s" % (self.vm_to_migrate.id, migrate_host.id)) self.vm_to_migrate.migrate(self.api_client, migrate_host.id) list_vm_response = list_virtual_machines(self.apiclient, id=self.vm_to_migrate.id) self.assertNotEqual(list_vm_response, None, "Check virtual machine is listed") vm_response = list_vm_response[0] self.assertEqual(vm_response.id, self.vm_to_migrate.id, "Check virtual machine ID of migrated VM") self.assertEqual(vm_response.hostid, migrate_host.id, "Check destination hostID of migrated VM") return
def test_08_migrate_vm(self): """Test migrate VM """ # Validate the following # 1. Environment has enough hosts for migration # 2. DeployVM on suitable host (with another host in the cluster) # 3. Migrate the VM and assert migration successful suitable_hosts = None hosts = Host.list( self.apiclient, zoneid=self.zone.id, type='Routing' ) self.assertEqual(validateList(hosts)[0], PASS, "hosts list validation failed") if len(hosts) < 2: self.skipTest("At least two hosts should be present in the zone for migration") hypervisor = str(get_hypervisor_type(self.apiclient)).lower() # For KVM, two hosts used for migration should be present in same cluster # For XenServer and VMware, migration is possible between hosts belonging to different clusters # with the help of XenMotion and Vmotion respectively. if hypervisor == "kvm": #identify suitable host clusters = [h.clusterid for h in hosts] #find hosts withe same clusterid clusters = [cluster for index, cluster in enumerate(clusters) if clusters.count(cluster) > 1] if len(clusters) <= 1: self.skipTest("In KVM, Live Migration needs two hosts within same cluster") suitable_hosts = [host for host in hosts if host.clusterid == clusters[0]] else: suitable_hosts = hosts target_host = suitable_hosts[0] migrate_host = suitable_hosts[1] #deploy VM on target host self.vm_to_migrate = VirtualMachine.create( self.api_client, self.services["small"], accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.small_offering.id, mode=self.services["mode"], hostid=target_host.id ) self.debug("Migrating VM-ID: %s to Host: %s" % ( self.vm_to_migrate.id, migrate_host.id )) self.vm_to_migrate.migrate(self.api_client, migrate_host.id) list_vm_response = list_virtual_machines( self.apiclient, id=self.vm_to_migrate.id ) self.assertNotEqual( list_vm_response, None, "Check virtual machine is listed" ) vm_response = list_vm_response[0] self.assertEqual( vm_response.id, self.vm_to_migrate.id, "Check virtual machine ID of migrated VM" ) self.assertEqual( vm_response.hostid, migrate_host.id, "Check destination hostID of migrated VM" ) return
def test_vmware_anti_affinity(self): """ Test Set up anti-affinity rules The test requires following pre-requisites - VMWare cluster configured in fully automated mode """ # Validate the following # 1. Deploy VMs on host 1 and 2 # 2. Enable maintenance mode for host 1 # 3. VM should be migrated to 3rd host hosts = Host.list( self.apiclient, zoneid=self.zone.id, resourcestate='Enabled', type='Routing' ) self.assertEqual( isinstance(hosts, list), True, "List hosts should return valid host response" ) self.debug(len(hosts)) self.assertGreaterEqual( len(hosts), 3, "There must be at least 3 hosts present in a cluster" ) aff_grp = self.create_aff_grp(aff_grp=self.services["host_anti_affinity"], acc=self.account.name, domainid=self.domain.id) vm_1 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, affinitygroupnames=[aff_grp.name] ) vm_2 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, affinitygroupnames=[aff_grp.name] ) host_1 = vm_1.hostid host_2 = vm_2.hostid vms = VirtualMachine.list( self.apiclient, id=vm_1.id, listall=True ) vm_list_validation_result = validateList(vms) self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[1]) virtual_machine_1 = vm_list_validation_result[1] self.debug("VM State: %s" % virtual_machine_1.state) self.assertEqual( virtual_machine_1.state, "Running", "Deployed VM should be in RUnning state" ) vms = VirtualMachine.list( self.apiclient, id=vm_2.id, listall=True ) vm_list_validation_result = validateList(vms) self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[1]) virtual_machine_2 = vm_list_validation_result[1] self.debug("VM %s State: %s" % ( virtual_machine_2.name, virtual_machine_2.state )) self.assertEqual( virtual_machine_2.state, "Running", "Deployed VM should be in RUnning state" ) self.debug("Enabling maintenance mode on host_1: %s" % host_1) cmd = prepareHostForMaintenance.prepareHostForMaintenanceCmd() cmd.id = host_1 self.apiclient.prepareHostForMaintenance(cmd) timeout = self.services["timeout"] while True: hosts = Host.list( self.apiclient, zoneid=self.zone.id, type='Routing', id=host_1 ) host_list_validation_result = validateList(hosts) self.assertEqual(host_list_validation_result[0], PASS, "host list validation failed due to %s" % host_list_validation_result[2]) host = host_list_validation_result[1] if host.resourcestate == 'Maintenance': break elif timeout == 0: self.fail("Failed to put host: %s in maintenance mode" % host.name) time.sleep(self.services["sleep"]) timeout = timeout - 1 vms = VirtualMachine.list( self.apiclient, id=virtual_machine_1.id, listall=True ) vm_list_validation_result = validateList(vms) self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) vm = vm_list_validation_result[0] self.assertEqual( vm.state, "Running", "Deployed VM should be in RUnning state" ) self.assertNotEqual( vm.hostid, host_2, "The host name should not match with second host name" ) self.debug("Canceling host maintenance for ID: %s" % host_1.id) cmd = cancelHostMaintenance.cancelHostMaintenanceCmd() cmd.id = host_1.id self.apiclient.cancelHostMaintenance(cmd) self.debug("Maintenance mode canceled for host: %s" % host_1.id) return
def test_vmware_affinity(self): """ Test Set up affinity rules The test requires following pre-requisites - VMWare cluster configured in fully automated mode """ # Validate the following # 1. Deploy 2 VMs on same hosts # 2. Migrate one VM from one host to another # 3. The second VM should also get migrated hosts = Host.list( self.apiclient, zoneid=self.zone.id, resourcestate='Enabled', type='Routing' ) self.assertEqual( isinstance(hosts, list), True, "List hosts should return valid host response" ) self.assertGreaterEqual( len(hosts), 2, "There must be two hosts present in a cluster" ) host_1 = hosts[0].id host_2 = hosts[1].id aff_grp = self.create_aff_grp(aff_grp=self.services["host_affinity"], acc=self.account.name, domainid=self.domain.id) vm_1 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, affinitygroupnames=[aff_grp.name], hostid = host_1 ) vm_2 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, affinitygroupnames=[aff_grp.name] ) vms = VirtualMachine.list( self.apiclient, id= vm_1.id, listall=True ) vm_list_validation_result = validateList(vms) self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) virtual_machine_1 = vm_list_validation_result[1] self.assertEqual( virtual_machine_1.state, "Running", "Deployed VM should be in RUnning state" ) self.debug("Deploying VM on account: %s" % self.account.name) vms = VirtualMachine.list( self.apiclient, id=vm_2.id, listall=True ) vm_list_validation_result = validateList(vms) self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) virtual_machine_2 = vm_list_validation_result[1] self.assertEqual( virtual_machine_2.state, "Running", "Deployed VM should be in RUnning state" ) self.debug("Migrate VM from host_1 to host_2") cmd = migrateVirtualMachine.migrateVirtualMachineCmd() cmd.virtualmachineid = virtual_machine_2.id cmd.hostid = host_2 self.apiclient.migrateVirtualMachine(cmd) self.debug("Migrated VM from host_1 to host_2") vms = VirtualMachine.list( self.apiclient, hostid=host_2, listall=True ) vm_list_validation_result = validateList(vms) self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) vmids = [vm.id for vm in vms] self.assertIn( virtual_machine_1.id, vmids, "VM 1 should be successfully migrated to host 2" ) self.assertIn( virtual_machine_2.id, vmids, "VM 2 should be automatically migrated to host 2" ) return
def test_vmware_anti_affinity(self): """ Test Set up anti-affinity rules The test requires following pre-requisites - VMWare cluster configured in fully automated mode """ # Validate the following # 1. Deploy VMs on host 1 and 2 # 2. Enable maintenance mode for host 1 # 3. VM should be migrated to 3rd host hosts = Host.list(self.apiclient, zoneid=self.zone.id, resourcestate='Enabled', type='Routing') self.assertEqual(isinstance(hosts, list), True, "List hosts should return valid host response") self.debug(len(hosts)) self.assertGreaterEqual( len(hosts), 3, "There must be at least 3 hosts present in a cluster") aff_grp = self.create_aff_grp( aff_grp=self.services["host_anti_affinity"], acc=self.account.name, domainid=self.domain.id) vm_1 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, affinitygroupnames=[aff_grp.name]) vm_2 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, affinitygroupnames=[aff_grp.name]) host_1 = vm_1.hostid host_2 = vm_2.hostid vms = VirtualMachine.list(self.apiclient, id=vm_1.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[1]) virtual_machine_1 = vm_list_validation_result[1] self.debug("VM State: %s" % virtual_machine_1.state) self.assertEqual(virtual_machine_1.state, "Running", "Deployed VM should be in RUnning state") vms = VirtualMachine.list(self.apiclient, id=vm_2.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[1]) virtual_machine_2 = vm_list_validation_result[1] self.debug("VM %s State: %s" % (virtual_machine_2.name, virtual_machine_2.state)) self.assertEqual(virtual_machine_2.state, "Running", "Deployed VM should be in RUnning state") self.debug("Enabling maintenance mode on host_1: %s" % host_1) cmd = prepareHostForMaintenance.prepareHostForMaintenanceCmd() cmd.id = host_1 self.apiclient.prepareHostForMaintenance(cmd) timeout = self.services["timeout"] while True: hosts = Host.list(self.apiclient, zoneid=self.zone.id, type='Routing', id=host_1) host_list_validation_result = validateList(hosts) self.assertEqual( host_list_validation_result[0], PASS, "host list validation failed due to %s" % host_list_validation_result[2]) host = host_list_validation_result[1] if host.resourcestate == 'Maintenance': break elif timeout == 0: self.fail("Failed to put host: %s in maintenance mode" % host.name) time.sleep(self.services["sleep"]) timeout = timeout - 1 vms = VirtualMachine.list(self.apiclient, id=virtual_machine_1.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) vm = vm_list_validation_result[0] self.assertEqual(vm.state, "Running", "Deployed VM should be in RUnning state") self.assertNotEqual( vm.hostid, host_2, "The host name should not match with second host name") self.debug("Canceling host maintenance for ID: %s" % host_1.id) cmd = cancelHostMaintenance.cancelHostMaintenanceCmd() cmd.id = host_1.id self.apiclient.cancelHostMaintenance(cmd) self.debug("Maintenance mode canceled for host: %s" % host_1.id) return
def test_03_restore_vm_with_new_template(self): """ Test restoring a vm with different template than the one it was created with """ hosts = Host.list(self.apiclient, type="Routing", listall=True) host_list_validation_result = validateList(hosts) self.assertEqual( host_list_validation_result[0], PASS, "host list validation failed due to %s" % host_list_validation_result[2]) hypervisor = host_list_validation_result[1].hypervisor for k, v in self.services["templates"].items(): if k == hypervisor: # Register new template template = Template.register(self.apiclient, v, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) self.debug("Registered a template of format: %s with ID: %s" % (v["format"], template.id)) self.debug("Downloading template with ID: %s" % (template.id)) template.download(self.apiclient) self.cleanup.append(template) # Wait for template status to be changed across time.sleep(self.services["sleep"]) self.verify_template_listing(template) # Restore a vm with the new template. self.vm_with_reset.restore(self.apiclient, templateid=template.id) self.vm_without_reset.restore(self.apiclient, templateid=template.id) # Make sure the VMs now have the new template ID # Make sure the Ip address of the VMs haven't changed self.debug("Checking template id of VM with isVolatile=True") vms = VirtualMachine.list(self.apiclient, id=self.vm_with_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "VM list validation failed due to %s" % vm_list_validation_result[2]) vm_with_reset = vm_list_validation_result[1] self.assertNotEqual( self.vm_with_reset.templateid, vm_with_reset.templateid, "VM created with IsVolatile=True has same templateid : %s after restore" % vm_with_reset.templateid) self.assertNotEqual( self.vm_with_reset.templateid, template.id, "VM created with IsVolatile=True has wrong templateid after restore Got:%s Expected: %s" % (self.vm_with_reset.templateid, template.id)) # Make sure it has the same IP after reboot self.assertEqual( self.vm_with_reset.nic[0].ipaddress, vm_with_reset.nic[0].ipaddress, "VM created with IsVolatile=True doesn't have same ip after restore. Got : %s Expected : %s" % (vm_with_reset.nic[0].ipaddress, self.vm_with_reset.nic[0].ipaddress)) # Check if the the root disk was not destroyed for isVolatile=False self.debug("Checking template id of VM with isVolatile=False") vms = VirtualMachine.list(self.apiclient, id=self.vm_without_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "VM list validation failed due to %s" % vm_list_validation_result[2]) vm_without_reset = vm_list_validation_result[1] self.assertNotEqual( self.vm_without_reset.templateid, vm_without_reset.templateid, "VM created with IsVolatile=False has same templateid : %s after restore" % vm_with_reset.templateid) self.assertNotEqual( self.vm_without_reset.templateid, template.id, "VM created with IsVolatile=False has wrong templateid after restore Got:%s Expected: %s" % (self.vm_without_reset.templateid, template.id)) # Make sure it has the same IP after reboot self.assertEqual( self.vm_without_reset.nic[0].ipaddress, vm_without_reset.nic[0].ipaddress, "VM created with IsVolatile=False doesn't have same ip after restore. Got : %s Expected : %s" % (vm_without_reset.nic[0].ipaddress, self.vm_without_reset.nic[0].ipaddress)) return
def test_02_reboot_instance_with_is_volatile_offering(self): """ Test rebooting instances created with isVolatile service offerings """ # Validate the following # 1. Reboot the virtual machines. # 2. Validate the following # a. VM with created with isVolatile=True should have new Root disk but same IP # b. VM with created with isVolatile=False should have same Root disk and IP as before reboot self.debug("Rebooting the virtual machines in account: %s" % self.account.name) try: self.vm_with_reset.reboot(self.apiclient) self.vm_without_reset.reboot(self.apiclient) except Exception as e: self.fail("Failed to reboot the virtual machines, %s" % e) # Check if the the root disk was destroyed and recreated for isVolatile=True self.debug("Checking root disk of VM with isVolatile=True") vms = VirtualMachine.list(self.apiclient, id=self.vm_with_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "VM list validation failed due to %s" % vm_list_validation_result[2]) vm_with_reset = vm_list_validation_result[1] vm_with_reset_root_disk_id = self.get_root_device_uuid_for_vm( vm_with_reset.id, vm_with_reset.rootdeviceid) self.assertNotEqual( self.vm_with_reset_root_disk_id, vm_with_reset_root_disk_id, "VM created with IsVolatile=True has same rootdeviceid : %s after reboot" % vm_with_reset_root_disk_id) # Make sure it has the same IP after reboot self.assertEqual( self.vm_with_reset.nic[0].ipaddress, vm_with_reset.nic[0].ipaddress, "VM created with IsVolatile=True doesn't have same ip after reboot. Got : %s Expected : %s" % (vm_with_reset.nic[0].ipaddress, self.vm_with_reset.nic[0].ipaddress)) # Check if the the root disk was not destroyed for isVolatile=False self.debug("Checking root disk of VM with isVolatile=False") vms = VirtualMachine.list(self.apiclient, id=self.vm_without_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "list validation failed due to %s" % vm_list_validation_result[2]) vm_without_reset = vm_list_validation_result[1] vm_without_reset_root_disk_id = self.get_root_device_uuid_for_vm( vm_without_reset.id, vm_without_reset.rootdeviceid) self.assertEqual( self.vm_without_reset_root_disk_id, vm_without_reset_root_disk_id, "VM created with IsVolatile=False has different rootdeviceid after reboot Got: %s Expected : %s" % (vm_without_reset_root_disk_id, self.vm_without_reset_root_disk_id)) # Make sure it has the same IP after reboot self.assertEqual( self.vm_without_reset.nic[0].ipaddress, vm_without_reset.nic[0].ipaddress, "VM created with IsVolatile=True doesn't have same ip after reboot. Got : %s Expected : %s" % (vm_without_reset.nic[0].ipaddress, self.vm_without_reset.nic[0].ipaddress)) return
def test_03_restore_vm_with_new_template(self): """ Test restoring a vm with different template than the one it was created with """ hosts = Host.list(self.apiclient, type="Routing", listall=True) host_list_validation_result = validateList(hosts) self.assertEqual( host_list_validation_result[0], PASS, "host list validation failed due to %s" % host_list_validation_result[2], ) hypervisor = host_list_validation_result[1].hypervisor for k, v in self.services["templates"].items(): if k.lower() == hypervisor.lower(): # Register new template template = Template.register( self.apiclient, v, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid ) self.debug("Registered a template of format: %s with ID: %s" % (v["format"], template.id)) self.debug("Downloading template with ID: %s" % (template.id)) template.download(self.apiclient) self.cleanup.append(template) # Wait for template status to be changed across time.sleep(self.services["sleep"]) self.verify_template_listing(template) # Restore a vm with the new template. self.vm_with_reset.restore(self.apiclient, templateid=template.id) self.vm_without_reset.restore(self.apiclient, templateid=template.id) # Make sure the VMs now have the new template ID # Make sure the Ip address of the VMs haven't changed self.debug("Checking template id of VM with isVolatile=True") vms = VirtualMachine.list(self.apiclient, id=self.vm_with_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "VM list validation failed due to %s" % vm_list_validation_result[2], ) vm_with_reset = vm_list_validation_result[1] self.assertNotEqual( self.vm_with_reset.templateid, vm_with_reset.templateid, "VM created with IsVolatile=True has same templateid : %s after restore" % vm_with_reset.templateid, ) self.assertNotEqual( self.vm_with_reset.templateid, template.id, "VM created with IsVolatile=True has wrong templateid after restore Got:%s Expected: %s" % (self.vm_with_reset.templateid, template.id), ) # Make sure it has the same IP after reboot self.assertEqual( self.vm_with_reset.nic[0].ipaddress, vm_with_reset.nic[0].ipaddress, "VM created with IsVolatile=True doesn't have same ip after restore. Got : %s Expected : %s" % (vm_with_reset.nic[0].ipaddress, self.vm_with_reset.nic[0].ipaddress), ) # Check if the the root disk was not destroyed for isVolatile=False self.debug("Checking template id of VM with isVolatile=False") vms = VirtualMachine.list(self.apiclient, id=self.vm_without_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "VM list validation failed due to %s" % vm_list_validation_result[2], ) vm_without_reset = vm_list_validation_result[1] self.assertNotEqual( self.vm_without_reset.templateid, vm_without_reset.templateid, "VM created with IsVolatile=False has same templateid : %s after restore" % vm_with_reset.templateid, ) self.assertNotEqual( self.vm_without_reset.templateid, template.id, "VM created with IsVolatile=False has wrong templateid after restore Got:%s Expected: %s" % (self.vm_without_reset.templateid, template.id), ) # Make sure it has the same IP after reboot self.assertEqual( self.vm_without_reset.nic[0].ipaddress, vm_without_reset.nic[0].ipaddress, "VM created with IsVolatile=False doesn't have same ip after restore. Got : %s Expected : %s" % (vm_without_reset.nic[0].ipaddress, self.vm_without_reset.nic[0].ipaddress), ) return
def test_04_reoccuring_snapshot_rules(self): """ 1) Create a VM using the Service offering IsVolatile enabled 2) Apply a recurring snapshot rule on the Volume. 3) After a couple of snapshots are taken reboot the VM. Verify the following conditions 1) New root disk should be formed 2) The recurring snapshot rule should be deleted """ vms = VirtualMachine.list(self.apiclient, id=self.vm_with_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) vm_with_reset = vm_list_validation_result[1] vm_with_reset_root_disk_id = self.get_root_device_uuid_for_vm( vm_with_reset.id, vm_with_reset.rootdeviceid) now = datetime.now() delta = timedelta(minutes=15) scheduled_time = now + delta self.services["recurring_snapshot"]["schedule"] = scheduled_time.minute self.debug( "Creating recurring snapshot policy for root disk on vm created with IsVolatile=True" ) self.debug("Snapshot Policy - Type : %s Scheduled minute : %s" % (self.services["recurring_snapshot"]["intervaltype"], self.services["recurring_snapshot"]["schedule"])) recurring_snapshot = SnapshotPolicy.create( self.apiclient, vm_with_reset_root_disk_id, self.services["recurring_snapshot"]) #ListSnapshotPolicy should return newly created policy list_snapshots_policy = SnapshotPolicy.list( self.apiclient, id=recurring_snapshot.id, volumeid=vm_with_reset_root_disk_id) snapshot_list_validation_result = validateList(list_snapshots_policy) self.assertEqual( snapshot_list_validation_result[0], PASS, "snapshot list validation failed due to %s" % snapshot_list_validation_result[2]) snapshots_policy = snapshot_list_validation_result[1] self.assertEqual(snapshots_policy.id, recurring_snapshot.id, "Check recurring snapshot id in list resources call") self.assertEqual(snapshots_policy.maxsnaps, self.services["recurring_snapshot"]["maxsnaps"], "Check interval type in list resources call") sleep_seconds = delta.seconds + 600 sleep_minutes = sleep_seconds / 60 self.debug("Sleeping for %s minutes till the volume is snapshoted" % sleep_minutes) time.sleep(sleep_seconds) retriesCount = self.services["retriesCount"] while True: snapshots = Snapshot.list( self.apiclient, volumeid=vm_with_reset_root_disk_id, intervaltype=\ self.services["recurring_snapshot"]["intervaltype"], snapshottype=RECURRING, listall=True ) snapshot_list_validation_result = validateList(snapshots) if snapshot_list_validation_result[0] == PASS: break elif retriesCount == 0: self.fail("Failed to get snapshots list") time.sleep(60) retriesCount = retriesCount - 1 # rebooting the vm with isVolatile = True try: self.vm_with_reset.reboot(self.apiclient) except Exception as e: self.fail("Failed to reboot the virtual machine. Error: %s" % e) # Check if the the root disk was destroyed and recreated for isVolatile=True self.debug( "Checking whether root disk of VM with isVolatile=True was destroyed" ) vms = VirtualMachine.list(self.apiclient, id=self.vm_with_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "list validation failed due to %s" % vm_list_validation_result[2]) vm_with_reset_after_reboot = vm_list_validation_result[1] vm_with_reset_root_disk_id_after_reboot = self.get_root_device_uuid_for_vm( vm_with_reset_after_reboot.id, vm_with_reset_after_reboot.rootdeviceid) self.assertNotEqual( vm_with_reset_root_disk_id, vm_with_reset_root_disk_id_after_reboot, "VM created with IsVolatile=True has same rootdeviceid : %s after reboot" % vm_with_reset_root_disk_id_after_reboot) # Make sure it has the same IP after reboot self.assertEqual( vm_with_reset.nic[0].ipaddress, vm_with_reset_after_reboot.nic[0].ipaddress, "VM created with IsVolatile=True doesn't have same ip after reboot. Got : %s Expected : %s" % (vm_with_reset_after_reboot.nic[0].ipaddress, vm_with_reset.nic[0].ipaddress)) # Check whether the recurring policy has been deleted from the database self.debug( "Checking whether snapshot rule for VM with isVolatile=True was destroyed \ Here we are passing root disk id of vm before reboot which does not exist hence\ listing should fail") with self.assertRaises(Exception): list_snapshots_policy = SnapshotPolicy.list( self.apiclient, volumeid=vm_with_reset_root_disk_id) return
def test_04_reoccuring_snapshot_rules(self): """ 1) Create a VM using the Service offering IsVolatile enabled 2) Apply a recurring snapshot rule on the Volume. 3) After a couple of snapshots are taken reboot the VM. Verify the following conditions 1) New root disk should be formed 2) The recurring snapshot rule should be deleted """ vms = VirtualMachine.list(self.apiclient, id=self.vm_with_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2] ) vm_with_reset = vm_list_validation_result[1] vm_with_reset_root_disk_id = self.get_root_device_uuid_for_vm(vm_with_reset.id, vm_with_reset.rootdeviceid) self.debug("Creating recurring snapshot policy for root disk on vm created with IsVolatile=True") self.debug( "Snapshot Policy - Type : %s Scheduled Hours : %s" % (self.services["recurring_snapshot"]["intervaltype"], self.services["recurring_snapshot"]["schedule"]) ) recurring_snapshot = SnapshotPolicy.create( self.apiclient, vm_with_reset_root_disk_id, self.services["recurring_snapshot"] ) # ListSnapshotPolicy should return newly created policy list_snapshots_policy = SnapshotPolicy.list( self.apiclient, id=recurring_snapshot.id, volumeid=vm_with_reset_root_disk_id ) snapshot_list_validation_result = validateList(list_snapshots_policy) self.assertEqual( snapshot_list_validation_result[0], PASS, "snapshot list validation failed due to %s" % snapshot_list_validation_result[2], ) snapshots_policy = snapshot_list_validation_result[1] self.assertEqual( snapshots_policy.id, recurring_snapshot.id, "Check recurring snapshot id in list resources call" ) self.assertEqual( snapshots_policy.maxsnaps, self.services["recurring_snapshot"]["maxsnaps"], "Check interval type in list resources call", ) sleep_seconds = (self.services["recurring_snapshot"]["schedule"]) * 3600 + 600 sleep_minutes = sleep_seconds / 60 self.debug("Sleeping for %s minutes till the volume is snapshoted" % sleep_minutes) time.sleep(sleep_seconds) retriesCount = self.services["retriesCount"] while True: snapshots = Snapshot.list( self.apiclient, volumeid=vm_with_reset_root_disk_id, intervaltype=self.services["recurring_snapshot"]["intervaltype"], snapshottype=RECURRING, listall=True, ) snapshot_list_validation_result = validateList(snapshots) if snapshot_list_validation_result[0] == PASS: break elif retriesCount == 0: self.fail("Failed to get snapshots list") time.sleep(60) retriesCount = retriesCount - 1 # rebooting the vm with isVolatile = True try: self.vm_with_reset.reboot(self.apiclient) except Exception as e: self.fail("Failed to reboot the virtual machine. Error: %s" % e) # Check if the the root disk was destroyed and recreated for isVolatile=True self.debug("Checking whether root disk of VM with isVolatile=True was destroyed") vms = VirtualMachine.list(self.apiclient, id=self.vm_with_reset.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "list validation failed due to %s" % vm_list_validation_result[2] ) vm_with_reset_after_reboot = vm_list_validation_result[1] vm_with_reset_root_disk_id_after_reboot = self.get_root_device_uuid_for_vm( vm_with_reset_after_reboot.id, vm_with_reset_after_reboot.rootdeviceid ) self.assertNotEqual( vm_with_reset_root_disk_id, vm_with_reset_root_disk_id_after_reboot, "VM created with IsVolatile=True has same rootdeviceid : %s after reboot" % vm_with_reset_root_disk_id_after_reboot, ) # Make sure it has the same IP after reboot self.assertEqual( vm_with_reset.nic[0].ipaddress, vm_with_reset_after_reboot.nic[0].ipaddress, "VM created with IsVolatile=True doesn't have same ip after reboot. Got : %s Expected : %s" % (vm_with_reset_after_reboot.nic[0].ipaddress, vm_with_reset.nic[0].ipaddress), ) # Check whether the recurring policy has been deleted from the database self.debug( "Checking whether snapshot rule for VM with isVolatile=True was destroyed \ Here we are passing root disk id of vm before reboot which does not exist hence\ listing should fail" ) with self.assertRaises(Exception): list_snapshots_policy = SnapshotPolicy.list(self.apiclient, volumeid=vm_with_reset_root_disk_id) return
def test_vmware_affinity(self): """ Test Set up affinity rules The test requires following pre-requisites - VMWare cluster configured in fully automated mode """ # Validate the following # 1. Deploy 2 VMs on same hosts # 2. Migrate one VM from one host to another # 3. The second VM should also get migrated hosts = Host.list(self.apiclient, zoneid=self.zone.id, resourcestate='Enabled', type='Routing') self.assertEqual(isinstance(hosts, list), True, "List hosts should return valid host response") self.assertGreaterEqual( len(hosts), 2, "There must be two hosts present in a cluster") host_1 = hosts[0].id host_2 = hosts[1].id aff_grp = self.create_aff_grp(aff_grp=self.services["host_affinity"], acc=self.account.name, domainid=self.domain.id) vm_1 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, affinitygroupnames=[aff_grp.name], hostid=host_1) vm_2 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.service_offering.id, affinitygroupnames=[aff_grp.name]) vms = VirtualMachine.list(self.apiclient, id=vm_1.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) virtual_machine_1 = vm_list_validation_result[1] self.assertEqual(virtual_machine_1.state, "Running", "Deployed VM should be in RUnning state") self.debug("Deploying VM on account: %s" % self.account.name) vms = VirtualMachine.list(self.apiclient, id=vm_2.id, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) virtual_machine_2 = vm_list_validation_result[1] self.assertEqual(virtual_machine_2.state, "Running", "Deployed VM should be in RUnning state") self.debug("Migrate VM from host_1 to host_2") cmd = migrateVirtualMachine.migrateVirtualMachineCmd() cmd.virtualmachineid = virtual_machine_2.id cmd.hostid = host_2 self.apiclient.migrateVirtualMachine(cmd) self.debug("Migrated VM from host_1 to host_2") vms = VirtualMachine.list(self.apiclient, hostid=host_2, listall=True) vm_list_validation_result = validateList(vms) self.assertEqual( vm_list_validation_result[0], PASS, "vm list validation failed due to %s" % vm_list_validation_result[2]) vmids = [vm.id for vm in vms] self.assertIn(virtual_machine_1.id, vmids, "VM 1 should be successfully migrated to host 2") self.assertIn(virtual_machine_2.id, vmids, "VM 2 should be automatically migrated to host 2") return
def test_check_vm_stats(self, value): """Deploy VM with dynamic service offering and check VM stats""" # Steps: # 1. Create admin/user account and create its user api client # 2. Create a dynamic service offering # 3. Deploy a VM with account api client and dynamic service offering # providing custom values for cpu number, cpu speed and memory # 4. List the VM and verify the dynamic parameters are same as passed isadmin=True if value == USER_ACCOUNT: isadmin=False # Create Account and api client self.account = Account.create(self.apiclient,self.services["account"],domainid=self.domain.id, admin=isadmin) apiclient = self.testClient.createUserApiClient( UserName=self.account.name, DomainName=self.account.domain) self.cleanup.append(self.account) # Create dynamic compute offering self.services["service_offering"]["cpunumber"] = "" self.services["service_offering"]["cpuspeed"] = "" self.services["service_offering"]["memory"] = "" serviceOffering = ServiceOffering.create(self.apiclient, self.services["service_offering"]) self.cleanup_co.append(serviceOffering) # Custom values customcpunumber = 2 customcpuspeed = 256 custommemory = 128 # Deploy VM with dynamic service offering and the custom values try: virtualMachine = VirtualMachine.create(apiclient,self.services["virtual_machine"], serviceofferingid=serviceOffering.id, customcpunumber=customcpunumber, customcpuspeed=customcpuspeed, custommemory=custommemory, accountid=self.account.name,domainid=self.account.domainid) except Exception as e: self.fail("vm creation failed: %s" % e) vmlist = VirtualMachine.list(self.apiclient, id=virtualMachine.id) self.assertEqual(validateList(vmlist)[0], PASS, "vm list validation failed") vm = vmlist[0] # Verify the custom values self.assertEqual(str(vm.cpunumber), str(customcpunumber), "vm cpu number %s\ not matching with provided custom cpu number %s" % \ (vm.cpunumber, customcpunumber)) self.assertEqual(str(vm.cpuspeed), str(customcpuspeed), "vm cpu speed %s\ not matching with provided custom cpu speed %s" % \ (vm.cpuspeed, customcpuspeed)) self.assertEqual(str(vm.memory), str(custommemory), "vm memory %s\ not matching with provided custom memory %s" % \ (vm.memory, custommemory)) return