CLOUDSTACK-7594: Adding automation test cases for stopped VM test path Signed-off-by: SrikanteswaraRao Talluri <tall...@apache.org>
Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/04409609 Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/04409609 Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/04409609 Branch: refs/heads/master Commit: 04409609336f3aee1bc91c875dd3c3badcc71ae5 Parents: ba08229 Author: Ashutosh K <ashut...@clogeny.com> Authored: Sun Feb 15 20:46:40 2015 -0800 Committer: SrikanteswaraRao Talluri <tall...@apache.org> Committed: Fri Feb 20 20:02:08 2015 +0530 ---------------------------------------------------------------------- .../testpaths/testpath_stopped_vm.py | 1006 ++++++++++++++++++ 1 file changed, 1006 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cloudstack/blob/04409609/test/integration/testpaths/testpath_stopped_vm.py ---------------------------------------------------------------------- diff --git a/test/integration/testpaths/testpath_stopped_vm.py b/test/integration/testpaths/testpath_stopped_vm.py new file mode 100644 index 0000000..18a17c3 --- /dev/null +++ b/test/integration/testpaths/testpath_stopped_vm.py @@ -0,0 +1,1006 @@ +# 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. +""" Test Path for Deploy VM in stopped state +""" +from nose.plugins.attrib import attr +from marvin.cloudstackTestCase import cloudstackTestCase +from marvin.lib.utils import (cleanup_resources, + validateList) +from marvin.lib.base import (Account, + ServiceOffering, + VirtualMachine, + User, + Network, + Router, + DiskOffering, + Volume, + Iso, + Template, + Resources) +from marvin.lib.common import (get_domain, + get_zone, + get_template, + createEnabledNetworkOffering, + wait_for_cleanup) +from marvin.codes import (PASS, + STOPPED, + RUNNING, + FAIL) +from marvin.sshClient import SshClient +import time + + +def VerifyChangeInServiceOffering(self, virtualmachine, serviceoffering): + """List the VM and verify that the new values for cpuspeed, + cpunumber and memory match with the new service offering""" + + exceptionOccured = False + exceptionMessage = "" + try: + vmlist = VirtualMachine.list(self.userapiclient, 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(serviceoffering.cpunumber), + "vm cpu number %s not matching with cpu number in\ + service offering %s" % + (vm.cpunumber, serviceoffering.cpunumber)) + + self.assertEqual(str(vm.cpuspeed), str(serviceoffering.cpuspeed), + "vm cpu speed %s not matching with cpu speed in\ + service offering %s" % + (vm.cpuspeed, serviceoffering.cpuspeed)) + + self.assertEqual(str(vm.memory), str(serviceoffering.memory), + "vm memory %s not matching with memory in\ + service offering %s" % + (vm.memory, serviceoffering.memory)) + except Exception as e: + exceptionOccured = True + exceptionMessage = e + return [exceptionOccured, exceptionMessage] + + +def VerifyRouterState(apiclient, account, domainid, desiredState, + retries=0): + """List the router associated with the account and + verify that router state matches with the desired state + Return PASS/FAIL depending upon whether router state matches + or not""" + + isRouterStateDesired = False + failureMessage = "" + while retries >= 0: + routers = Router.list( + apiclient, + account=account, + domainid=domainid, + listall=True + ) + if str(routers[0].state).lower() == str(desiredState).lower(): + isRouterStateDesired = True + break + time.sleep(60) + retries -= 1 + # whileEnd + + if not isRouterStateDesired: + failureMessage = "Router state should be %s,\ + but it is %s" %\ + (desiredState, routers[0].state) + return [isRouterStateDesired, failureMessage] + + +def CreateEnabledNetworkOffering(apiclient, networkServices): + """Create network offering of given services and enable it""" + + result = createEnabledNetworkOffering(apiclient, networkServices) + assert result[0] == PASS,\ + "Network offering creation/enabling failed due to %s" % result[2] + return result[1] + + +class TestAdvancedZoneStoppedVM(cloudstackTestCase): + + @classmethod + def setUpClass(cls): + testClient = super(TestAdvancedZoneStoppedVM, cls).getClsTestClient() + cls.apiclient = testClient.getApiClient() + cls.testdata = testClient.getParsedTestDataConfig() + + # Get Zone, Domain and templates + cls.domain = get_domain(cls.apiclient) + cls.zone = get_zone(cls.apiclient) + cls._cleanup = [] + + try: + # Create an account + cls.account = Account.create( + cls.apiclient, + cls.testdata["account"], + domainid=cls.domain.id + ) + cls._cleanup.append(cls.account) + + # If local storage is enabled, alter the offerings to use + # localstorage + if cls.zone.localstorageenable: + cls.testdata["service_offering"]["storagetype"] = 'local' + + # Create 2 service offerings with different values for + # for cpunumber, cpuspeed, and memory + + cls.testdata["service_offering"]["cpunumber"] = "1" + cls.testdata["service_offering"]["cpuspeed"] = "128" + cls.testdata["service_offering"]["memory"] = "256" + + cls.service_offering = ServiceOffering.create( + cls.apiclient, + cls.testdata["service_offering"] + ) + cls._cleanup.append(cls.service_offering) + + cls.testdata["service_offering"]["cpunumber"] = "2" + cls.testdata["service_offering"]["cpuspeed"] = "256" + cls.testdata["service_offering"]["memory"] = "512" + + cls.service_offering_2 = ServiceOffering.create( + cls.apiclient, + cls.testdata["service_offering"] + ) + cls._cleanup.append(cls.service_offering_2) + + # Create isolated network offering + cls.isolated_network_offering = CreateEnabledNetworkOffering( + cls.apiclient, + cls.testdata["isolated_network_offering"] + ) + cls._cleanup.append(cls.isolated_network_offering) + + cls.networkid = None + if str(cls.zone.networktype).lower() == "advanced": + cls.network = Network.create( + cls.apiclient, cls.testdata["isolated_network"], + networkofferingid=cls.isolated_network_offering.id, + accountid=cls.account.name, + domainid=cls.account.domainid, + zoneid=cls.zone.id) + cls.networkid = cls.network.id + + # Create user api client of the account + cls.userapiclient = testClient.getUserApiClient( + UserName=cls.account.name, + DomainName=cls.account.domain + ) + + template = get_template( + cls.apiclient, + cls.zone.id, + cls.testdata["ostype"]) + cls.defaultTemplateId = template.id + # Set Zones and disk offerings + + # Check that we are able to login to the created account + respose = User.login( + cls.apiclient, + username=cls.account.name, + password=cls.testdata["account"]["password"] + ) + + assert respose.sessionkey is not None,\ + "Login to the CloudStack should be successful\ + response shall have non Null key" + + except Exception as e: + cls.tearDownClass() + raise e + return + + @classmethod + def tearDownClass(cls): + try: + cleanup_resources(cls.apiclient, cls._cleanup) + except Exception as e: + raise Exception("Warning: Exception during cleanup : %s" % e) + + def setUp(self): + self.apiclient = self.testClient.getApiClient() + self.cleanup = [] + + def tearDown(self): + try: + cleanup_resources(self.apiclient, self.cleanup) + # Wait for Router cleanup before runnign further test case + wait_for_cleanup( + self.apiclient, [ + "network.gc.interval", "network.gc.wait"]) + except Exception as e: + raise Exception("Warning: Exception during cleanup : %s" % e) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_01_pt_deploy_vm_without_startvm(self): + """ Positive test for stopped VM test path - T1 + + # 1. Deploy VM in the network without specifying startvm parameter + # 2. List VMs and verify that VM is in running state + # 3. Verify that router is in running state (Advanced zone) + # 4. Add network rules for VM (done in base.py itself) to make + # it accessible + # 5. Verify that VM is accessible + # 6. Destroy and expunge the VM + # 7. Wait for network gc time interval and check that router is + # in Stopped state + """ + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + mode=self.zone.networktype + ) + + response = virtual_machine.getState( + self.userapiclient, + VirtualMachine.RUNNING) + self.assertEqual(response[0], PASS, response[1]) + + if str(self.zone.networktype).lower() == "advanced": + response = VerifyRouterState( + self.apiclient, + self.account.name, + self.account.domainid, + RUNNING + ) + self.assertTrue(response[0], response[1]) + + # Check VM accessibility + try: + SshClient(host=virtual_machine.ssh_ip, + port=self.testdata["natrule"]["publicport"], + user=virtual_machine.username, + passwd=virtual_machine.password) + except Exception as e: + self.fail("Exception while SSHing to VM: %s" % e) + + virtual_machine.delete(self.apiclient) + + if str(self.zone.networktype).lower() == "advanced": + # Wait for router to go into stopped state + wait_for_cleanup( + self.apiclient, [ + "network.gc.interval", "network.gc.wait"]) + + response = VerifyRouterState( + self.apiclient, + self.account.name, + self.account.domainid, + STOPPED, + retries=10 + ) + self.assertTrue(response[0], response[1]) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_02_pt_deploy_vm_with_startvm_true(self): + """ Positive test for stopped VM test path - T1 variant + + # 1. Deploy VM in the network specifying startvm parameter as True + # 2. List VMs and verify that VM is in running state + # 3. Verify that router is in running state (Advanced zone) + # 4. Add network rules for VM (done in base.py itself) to make + # it accessible + # 5. Verify that VM is accessible + # 6. Destroy and expunge the VM + # 7. Wait for network gc time interval and check that router is + # in stopped state + """ + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + startvm=True, + mode=self.zone.networktype + ) + + response = virtual_machine.getState( + self.userapiclient, + VirtualMachine.RUNNING) + self.assertEqual(response[0], PASS, response[1]) + + if str(self.zone.networktype).lower() == "advanced": + response = VerifyRouterState( + self.apiclient, + self.account.name, + self.account.domainid, + RUNNING + ) + self.assertTrue(response[0], response[1]) + + # Check VM accessibility + try: + SshClient(host=virtual_machine.ssh_ip, + port=self.testdata["natrule"]["publicport"], + user=virtual_machine.username, + passwd=virtual_machine.password) + except Exception as e: + self.fail("Exception while SSHing to VM: %s" % e) + + virtual_machine.delete(self.apiclient) + + if str(self.zone.networktype).lower() == "advanced": + # Wait for router to get router in stopped state + wait_for_cleanup( + self.apiclient, [ + "network.gc.interval", "network.gc.wait"]) + + response = VerifyRouterState( + self.apiclient, + self.account.name, + self.account.domainid, + STOPPED, + retries=10 + ) + self.assertTrue(response[0], response[1]) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_03_pt_deploy_vm_with_startvm_false(self): + """ Positive test for stopped VM test path - T2 + + # 1. Deploy VM in the network with specifying startvm parameter + # as False + # 2. List VMs and verify that VM is in stopped state + # For Advanced zone + # 3. Start the VM, now router should be in running state + """ + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + self.cleanup.append(virtual_machine) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + if str(self.zone.networktype).lower() == "advanced": + virtual_machine.start(self.userapiclient) + + response = VerifyRouterState( + self.apiclient, + self.account.name, + self.account.domainid, + RUNNING + ) + self.assertTrue(response[0], response[1]) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_04_pt_startvm_false_attach_disk(self): + """ Positive test for stopped VM test path - T3 and variant, T9 + + # 1. Deploy VM in the network with specifying startvm parameter + # as False + # 2. List VMs and verify that VM is in stopped state + # 3. Create a data disk and attach it to VM + # 4. Now detach the disk from the VM + # 5. Verify that attach and detach operations are successful + # 6. Deploy another VM in the account with startVM = False + # 7. Attach the same volume to this VM + # 8. Detach the volume + # 9. Both attach and detach operations should be successful + """ + + disk_offering = DiskOffering.create( + self.apiclient, + self.testdata["disk_offering"] + ) + self.cleanup.append(disk_offering) + + volume = Volume.create( + self.apiclient, self.testdata["volume"], + zoneid=self.zone.id, account=self.account.name, + domainid=self.account.domainid, diskofferingid=disk_offering.id + ) + self.cleanup.append(volume) + + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + self.cleanup.append(virtual_machine) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + virtual_machine.attach_volume(self.userapiclient, volume=volume) + + volumes = Volume.list( + self.userapiclient, + virtualmachineid=virtual_machine.id, + type="DATADISK", + listall=True + ) + self.assertEqual( + validateList(volumes)[0], + PASS, + "Volumes list validation failed" + ) + self.assertEqual( + volumes[0].id, + volume.id, + "Listed Volume id not matching with attached volume id" + ) + + virtual_machine.detach_volume( + self.userapiclient, + volume) + + volumes = Volume.list( + self.userapiclient, + virtualmachineid=virtual_machine.id, + type="DATADISK", + listall=True + ) + self.assertEqual( + validateList(volumes)[0], + FAIL, + "Detached volume should not be listed" + ) + + virtual_machine_2 = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + self.cleanup.append(virtual_machine_2) + + response = virtual_machine_2.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + virtual_machine_2.attach_volume(self.userapiclient, volume=volume) + + volumes = Volume.list( + self.userapiclient, + virtualmachineid=virtual_machine_2.id, + type="DATADISK", + listall=True + ) + self.assertEqual( + validateList(volumes)[0], + PASS, + "Volumes list validation failed" + ) + self.assertEqual( + volumes[0].id, + volume.id, + "Listed Volume id not matching with attached volume id" + ) + + virtual_machine_2.detach_volume( + self.userapiclient, + volume) + + volumes = Volume.list( + self.userapiclient, + virtualmachineid=virtual_machine_2.id, + type="DATADISK", + listall=True + ) + self.assertEqual( + validateList(volumes)[0], + FAIL, + "Detached volume should not be listed" + ) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_05_pt_startvm_false_attach_disk_change_SO(self): + """ Positive test for stopped VM test path - T4 + + # 1. Deploy VM in the network with specifying startvm parameter + # as False + # 2. List VMs and verify that VM is in stopped state + # 3. Create a data disk and attach it to VM + # 4. Change the service offering of VM from small to medium, + verify that the operation is successful + # 5. Start the VM + # 6. Now detach the disk from the VM + # 7. Verify that attach and detach operations are successful + """ + + disk_offering = DiskOffering.create( + self.apiclient, + self.testdata["disk_offering"] + ) + self.cleanup.append(disk_offering) + + volume = Volume.create( + self.apiclient, self.testdata["volume"], + zoneid=self.zone.id, account=self.account.name, + domainid=self.account.domainid, diskofferingid=disk_offering.id + ) + self.cleanup.append(volume) + + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + self.cleanup.append(virtual_machine) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + virtual_machine.attach_volume(self.userapiclient, volume=volume) + + volumes = Volume.list( + self.userapiclient, + virtualmachineid=virtual_machine.id, + type="DATADISK", + listall=True + ) + self.assertEqual( + validateList(volumes)[0], + PASS, + "Volumes list validation failed" + ) + self.assertEqual( + volumes[0].id, + volume.id, + "Listed Volume id not matching with attached volume id" + ) + + # Change service offering of VM and verify that it is changed + virtual_machine.change_service_offering( + self.userapiclient, + serviceOfferingId=self.service_offering_2.id + ) + + response = VerifyChangeInServiceOffering( + self, + virtual_machine, + self.service_offering_2 + ) + exceptionOccured, exceptionMessage = response[0], response[1] + self.assertFalse(exceptionOccured, exceptionMessage) + + virtual_machine.detach_volume( + self.userapiclient, + volume) + + volumes = Volume.list( + self.userapiclient, + virtualmachineid=virtual_machine.id, + type="DATADISK", + listall=True + ) + self.assertEqual( + validateList(volumes)[0], + FAIL, + "Detached volume should not be listed" + ) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_06_pt_startvm_false_attach_iso(self): + """ Positive test for stopped VM test path - T5 + + # 1. Deploy VM in the network with specifying startvm parameter + # as False + # 2. List VMs and verify that VM is in stopped state + # 3. Register an ISO and attach it to the VM + # 4. Verify that ISO is attached to the VM + """ + + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + self.cleanup.append(virtual_machine) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + iso = Iso.create( + self.userapiclient, + self.testdata["iso"], + account=self.account.name, + domainid=self.account.domainid, + zoneid=self.zone.id + ) + + iso.download(self.userapiclient) + virtual_machine.attach_iso(self.userapiclient, iso) + + vms = VirtualMachine.list( + self.userapiclient, + id=virtual_machine.id, + listall=True + ) + self.assertEqual( + validateList(vms)[0], + PASS, + "List vms should return a valid list" + ) + vm = vms[0] + self.assertEqual( + vm.isoid, + iso.id, + "The ISO status should be reflected in list Vm call" + ) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_07_pt_startvm_false_attach_iso_running_vm(self): + """ Positive test for stopped VM test path - T5 variant + + # 1. Deploy VM in the network with specifying startvm parameter + # as False + # 2. List VMs and verify that VM is in stopped state + # 3. Start the VM and verify that it is in running state + # 3. Register an ISO and attach it to the VM + # 4. Verify that ISO is attached to the VM + """ + + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + self.cleanup.append(virtual_machine) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + virtual_machine.start(self.userapiclient) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.RUNNING) + self.assertEqual(response[0], PASS, response[1]) + + iso = Iso.create( + self.userapiclient, + self.testdata["iso"], + account=self.account.name, + domainid=self.account.domainid, + zoneid=self.zone.id + ) + + iso.download(self.userapiclient) + virtual_machine.attach_iso(self.userapiclient, iso) + + vms = VirtualMachine.list( + self.userapiclient, + id=virtual_machine.id, + listall=True + ) + self.assertEqual( + validateList(vms)[0], + PASS, + "List vms should return a valid list" + ) + vm = vms[0] + self.assertEqual( + vm.isoid, + iso.id, + "The ISO status should be reflected in list Vm call" + ) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_08_pt_startvm_false_password_enabled_template(self): + """ Positive test for stopped VM test path - T10 + + # 1 Create a password enabled template + # 2. Deploy a new VM with password enabled template + # 3. Verify that VM is in stopped state + # 4. Start the VM, verify that it is in running state + # 5. Verify that new password is generated for the VM + """ + vm_for_template = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + zoneid=self.zone.id, + mode=self.zone.networktype, + networkids=[self.networkid, ] if self.networkid else None) + + vm_for_template.password = self.testdata["virtual_machine"]["password"] + ssh = vm_for_template.get_ssh_client() + + # below steps are required to get the new password from + # VR(reset password) + # http://cloudstack.org/dl/cloud-set-guest-password + # Copy this file to /etc/init.d + # chmod +x /etc/init.d/cloud-set-guest-password + # chkconfig --add cloud-set-guest-password + # similar steps to get SSH key from web so as to make it ssh enabled + + cmds = [ + "cd /etc/init.d;wget http://people.apache.org/~tsp/\ + cloud-set-guest-password", + "chmod +x /etc/init.d/cloud-set-guest-password", + "chkconfig --add cloud-set-guest-password"] + for c in cmds: + ssh.execute(c) + + # Stop virtual machine + vm_for_template.stop(self.userapiclient) + + list_volume = Volume.list( + self.userapiclient, + virtualmachineid=vm_for_template.id, + type='ROOT', + listall=True) + + if isinstance(list_volume, list): + self.volume = list_volume[0] + else: + raise Exception( + "Exception: Unable to find root volume for VM: %s" % + vm_for_template.id) + + self.testdata["template"]["ostype"] = self.testdata["ostype"] + # Create templates for Edit, Delete & update permissions testcases + pw_ssh_enabled_template = Template.create( + self.userapiclient, + self.testdata["template"], + self.volume.id, + account=self.account.name, + domainid=self.account.domainid + ) + self.cleanup.append(pw_ssh_enabled_template) + # Delete the VM - No longer needed + vm_for_template.delete(self.apiclient) + + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype, + networkids=[self.networkid, ] if self.networkid else None + ) + self.cleanup.append(virtual_machine) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + virtual_machine.start(self.userapiclient) + + vms = virtual_machine.list( + self.userapiclient, + id=virtual_machine.id, + listall=True) + + self.assertEqual( + validateList(vms)[0], + PASS, + "vms list validation failed" + ) + self.assertNotEqual( + str(vms[0].password), + str(virtual_machine.password), + "New password should be generated for the VM" + ) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_09_pt_destroy_stopped_vm(self): + """ Positive test for stopped VM test path - T11 + + # 1. Deploy VM in the network with specifying startvm parameter + # as False + # 2. Verify that VM is in Stopped state + # 3. Start the VM and verify that it is in running state + # 3. Stop the VM, verify that it is in Stopped state + # 4. Destroy the VM and verify that it is in Destroyed state + """ + # Create VM in account + virtual_machine = VirtualMachine.create( + self.userapiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=self.account.name, + domainid=self.account.domainid, + serviceofferingid=self.service_offering.id, + networkids=[self.networkid, ] if self.networkid else None, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + virtual_machine.start(self.userapiclient) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.RUNNING) + self.assertEqual(response[0], PASS, response[1]) + + virtual_machine.stop(self.userapiclient) + + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.STOPPED) + self.assertEqual(response[0], PASS, response[1]) + + virtual_machine.delete(self.apiclient, expunge=False) + response = virtual_machine.getState( + self.apiclient, + VirtualMachine.DESTROYED) + self.assertEqual(response[0], PASS, response[1]) + return + + @attr(tags=["advanced", "basic"], required_hardware="False") + def test_10_max_account_limit(self): + """ Positive test for stopped VM test path - T12 + + # 1. Create an account in root domain and set the VM limit + # to max 2 VMs + # 2. Deploy two VMs in the account with startvm parameter + # as false + # 3. Deployment of both VMs should be successful + # 4. Try to deploy 3rd VM with startvm False, deployment should fail + """ + + # Create an account + account = Account.create( + self.apiclient, + self.testdata["account"], + domainid=self.domain.id + ) + self.cleanup.append(account) + + Resources.updateLimit( + self.apiclient, + resourcetype=0, + max=2, + account=account.name, + domainid=account.domainid + ) + + VirtualMachine.create( + self.apiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=account.name, + domainid=account.domainid, + serviceofferingid=self.service_offering.id, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + + VirtualMachine.create( + self.apiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=account.name, + domainid=account.domainid, + serviceofferingid=self.service_offering.id, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + + with self.assertRaises(Exception): + VirtualMachine.create( + self.apiclient, + self.testdata["small"], + templateid=self.defaultTemplateId, + accountid=account.name, + domainid=account.domainid, + serviceofferingid=self.service_offering.id, + zoneid=self.zone.id, + startvm=False, + mode=self.zone.networktype + ) + return
