# 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 cases relating to enabling/diabling of zone/pod/cluster/host """ # Import System modules # Import System modules import traceback from marvin.cloudstackAPI import * from marvin.cloudstackAPI import * # Import Local Modules from marvin.cloudstackTestCase import * # Import Local Modules from marvin.cloudstackTestCase import * from marvin.lib.base import * from marvin.lib.base import * from marvin.lib.common import * from marvin.lib.common import * from marvin.lib.utils import * from marvin.lib.utils import * from nose.plugins.attrib import attr _multiprocess_shared_ = True class TestOrganizationStates(cloudstackTestCase): @classmethod def setUpClass(cls): try: cls.testclient = super(TestOrganizationStates, cls).getClsTestClient() cls.apiclient = cls.testclient.getApiClient() cls.testdata = cls.testClient.getParsedTestDataConfig() cls.cleanup = [] zone = get_zone(cls.apiclient, cls.testclient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls.template = get_template(cls.apiclient, cls.zone.id, cls.testdata["ostype"]) hostList = Host.list(cls.apiclient, zoneid=cls.zone.id, type="routing") cls.host = Host(hostList[0].__dict__) clusterList = Cluster.list(cls.apiclient, id=hostList[0].clusterid) cls.cluster = Cluster(clusterList[0].__dict__) podList = Pod.list(cls.apiclient, id=hostList[0].podid) cls.pod = Pod(podList[0].__dict__) cls.serviceOffering = ServiceOffering.create( cls.apiclient, cls.testdata["service_offering"], hosttags="test" ) hostupdResp = Host.update(cls.apiclient, id=cls.host.id, hosttags="test") userAccountName = "-".join(("TestOrgUser", random_gen())) adminAccountName = "-".join(("TestOrgAdmin", random_gen())) cls.user_apiclient = cls.testclient.getUserApiClient( UserName=userAccountName, DomainName="ROOT" ) cls.admin_apiclient = cls.testclient.getUserApiClient( UserName=adminAccountName, DomainName="ROOT", type=1 ) accountList = Account.list( cls.apiclient, name=userAccountName, listAll="true" ) cls.account = Account(accountList[0].__dict__) accountList = Account.list( cls.apiclient, name=adminAccountName, listAll="true" ) cls.adminAccount = Account(accountList[0].__dict__) cls.cleanup = [ cls.account, cls.adminAccount, cls.serviceOffering ] cls.vm_admin = VirtualMachine.create( cls.admin_apiclient, {}, zoneid=cls.zone.id, serviceofferingid=cls.serviceOffering.id, templateid=cls.template.id ) cls.vm_user = VirtualMachine.create( cls.user_apiclient, {}, zoneid=cls.zone.id, serviceofferingid=cls.serviceOffering.id, templateid=cls.template.id ) except Exception as e: printex = traceback.format_exc() cls.debug("Exception Occurred : {0}".format(printex)) cleanup_resources(cls.apiclient, cls.cleanup) raise Exception("Failed to create the setup required to execute the test cases: %s" % e) @classmethod def tearDownClass(cls): cls.apiclient = super(TestOrganizationStates, cls).getClsTestClient().getApiClient() hostupdResp = Host.update(cls.apiclient, id=cls.host.id, hosttags="") cleanup_resources(cls.apiclient, cls.cleanup) return def setUp(cls): return def tearDown(cls): return ## Test cases relating to disabling and enabling zone @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_11_disableZone(self): """ Disable Zone Validate that listZones() returns the allocationstate as "Disabled" """ self.debug("Zone to be disabled: " + self.zone.id) zoneupdResp = self.zone.update(self.apiclient, allocationstate="Disabled") self.assertEqual(zoneupdResp.allocationstate, "Disabled", "Disabling Zone did not set the alloctionstate to Disabled") zonelistResp = Zone.list(self.apiclient, id=self.zone.id) self.assertEqual(zonelistResp[0].allocationstate, "Disabled", "Disabling Zone did not set the alloctionstate to Disabled") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_12_disableZone_admin_deployVM(self): """ Validate that admin is allowed to deploy VM in a disabled zone """ vm = VirtualMachine.create( self.admin_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id ) self.assertEqual(vm.state, "Running", "Admin is not able to deploy Vm in a disabled Zone! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_13_disableZone_admin_stop_startVM(self): """ Validate that admin is allowed to stop and start existing VMs that are running on a disabled zone """ self.vm_admin.stop(self.apiclient) listResp = VirtualMachine.list(self.apiclient, id=self.vm_admin.id) self.assertEqual(listResp[0].state, VirtualMachine.STOPPED, "Admin is not able to Stop Vm in a disabled Zone! ") self.vm_admin.start(self.apiclient) listResp = VirtualMachine.list(self.admin_apiclient, id=self.vm_admin.id) self.assertEqual(listResp[0].state, VirtualMachine.RUNNING, "Admin is not able to Stop Vm in a disabled Zone! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_14_disableZone_user_deployVM(self): """ Validate that regular user is not allowed to deploy VM in a disabled zone """ try: vm = VirtualMachine.create( self.user_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id ) self.fail("Regular user is allowed to deploy VM in a zone that is disabled") except Exception as e: self.debug("Exception thrown when deploying Virtual Machine on a disabled zone - %s" % e) @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_15_disableZone_user_stop_startVM(self): """ Validate that regular user is allowed to stop and start existing VMs in a disabled zone """ self.vm_user.stop(self.user_apiclient) listResp = VirtualMachine.list(self.user_apiclient, id=self.vm_user.id) self.assertEqual(listResp[0].state, VirtualMachine.STOPPED, "Regular user is not able to Stop Vm in a disabled Zone! ") self.vm_user.start(self.user_apiclient) listResp = VirtualMachine.list(self.user_apiclient, id=self.vm_user.id) self.assertEqual(listResp[0].state, VirtualMachine.RUNNING, "Regular is not able to Stop Vm in a disabled Zone! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_16_enableZone(self): """ Enable Zone that is disabled Validate that listZones() returns the allocationstate as "Enabled" """ self.debug("Zone to be enabled: " + self.zone.id) zoneupdResp = self.zone.update(self.apiclient, allocationstate="Enabled") self.assertEqual(zoneupdResp.allocationstate, "Enabled", "Enabling Zone did not set the alloctionstate to Enabled") zonelistResp = Zone.list(self.apiclient, id=self.zone.id) self.assertEqual(zonelistResp[0].allocationstate, "Enabled", "Enabling Zone did not set the alloctionstate to Enabled") ## Test cases relating to disabling and enabling pod @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_21_disablePod(self): """ Disable Pod Validate that listPods() returns the allocationstate as "Disabled" """ self.debug("Pod to be disabled: " + self.zone.id) podupdResp = self.pod.update(self.apiclient, allocationstate="Disabled", id=self.pod.id) self.assertEqual(podupdResp.allocationstate, "Disabled", "Disabling Pod did not set the alloctionstate to Disabled") podlistResp = Pod.list(self.apiclient, id=self.pod.id) self.assertEqual(podlistResp[0].allocationstate, "Disabled", "Disabling Pod did not set the alloctionstate to Disabled") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_22_disablePod_admin_deployVM(self): """ Validate that admin is allowed to deploy VM in a disabled pod """ vm = VirtualMachine.create( self.admin_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id ) self.assertEqual(vm.state, "Running", "Admin is not able to deploy Vm in a disabled Pod! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_23_disablePod_admin_stop_startVM(self): """ Validate that admin is allowed to stop and start existing VMs running in a disabled pod """ self.vm_admin.stop(self.admin_apiclient) listResp = VirtualMachine.list(self.apiclient, id=self.vm_admin.id) self.assertEqual(listResp[0].state, VirtualMachine.STOPPED, "Admin is not able to Stop Vm in a disabled Pod! ") self.vm_admin.start(self.admin_apiclient) listResp = VirtualMachine.list(self.apiclient, id=self.vm_admin.id) self.assertEqual(listResp[0].state, VirtualMachine.RUNNING, "Admin is not able to Stop Vm in a disabled Pod! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_24_disablePod_user_deployVM(self): """ Validate that regular user is not allowed to deploy VM in a disabled pod """ try: vm = VirtualMachine.create( self.user_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id ) self.fail("Regular user is allowed to deploy VM in a zone that is disabled") except Exception as e: self.debug("Exception thrown when deploying Virtual Machine on a disabled zone - %s" % e) @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_25_disablePod_user_stop_startVM(self): """ Validate that regular user is allowed to stop and start existing VMs runing in a disabled pod """ self.vm_user.stop(self.user_apiclient) listResp = VirtualMachine.list(self.user_apiclient, id=self.vm_user.id) self.assertEqual(listResp[0].state, VirtualMachine.STOPPED, "Regular user is not able to Stop Vm in a disabled Pod! ") self.vm_user.start(self.user_apiclient) listResp = VirtualMachine.list(self.user_apiclient, id=self.vm_user.id) self.assertEqual(listResp[0].state, VirtualMachine.RUNNING, "Regular is not able to Stop Vm in a disabled Pod! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_26_enablePod(self): """ Enable Pod that is disabled Validate that listPods() returns the allocationstate as "Enabled" """ self.debug("Pod to be enabled: " + self.zone.id) podupdResp = self.pod.update(self.apiclient, allocationstate="Enabled", id=self.pod.id) self.assertEqual(podupdResp.allocationstate, "Enabled", "Enabling Pod did not set the alloctionstate to Enabled") podlistResp = Pod.list(self.apiclient, id=self.pod.id) self.assertEqual(podlistResp[0].allocationstate, "Enabled", "Enabling Pod did not set the alloctionstate to Enabled") ## Test cases relating to disabling and enabling cluster # was tags=["advanced"] @attr("disruptive", "simulator_only", tags=["TODO"], required_hardware="false") def test_31_disableCluster(self): """ Disable Cluster Validate that listClusters() returns the allocationstate as "Disabled" """ self.debug("Cluster to be disabled: " + self.cluster.id) clusterupdResp = self.cluster.update(self.apiclient, allocationstate="Disabled", id=self.cluster.id) self.assertEqual(clusterupdResp.allocationstate, "Disabled", "Disabling Cluster did not set the alloctionstate to Disabled") clusterlistResp = Cluster.list(self.apiclient, id=self.cluster.id) self.assertEqual(clusterlistResp[0].allocationstate, "Disabled", "Disabling Cluster did not set the alloctionstate to Disabled") # was tags=["advanced"] @attr("disruptive", "simulator_only", tags=["TODO"], required_hardware="false") def test_32_disableCluster_admin_deployVM(self): """ Validate that admin is allowed to deploy VM in a disabled cluster """ vm = VirtualMachine.create( self.admin_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id ) self.assertEqual(vm.state, "Running", "Admin is not able to deploy Vm in a disabled Cluster! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_33_disableCluster_admin_stop_startVM(self): """ Validate that admin is allowed to stop and start existing VMs that are running in a disabled cluster """ self.vm_admin.stop(self.admin_apiclient) listResp = VirtualMachine.list(self.apiclient, id=self.vm_admin.id) self.assertEqual(listResp[0].state, VirtualMachine.STOPPED, "Admin is not able to Stop Vm in a disabled Cluster! ") self.vm_admin.start(self.admin_apiclient) listResp = VirtualMachine.list(self.apiclient, id=self.vm_admin.id) self.assertEqual(listResp[0].state, VirtualMachine.RUNNING, "Admin is not able to Stop Vm in a disabled Cluster! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_34_disableCluster_user_deployVM(self): """ Validate that regular user is not allowed to deploy VM in a disabled cluster """ try: vm = VirtualMachine.create( self.user_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id ) self.fail("Regular user is allowed to deploy VM in a cluster that is disabled") except Exception as e: self.debug("Exception thrown when deploying Virtual Machine on a disabled cluster - %s" % e) @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_35_disableCluster_user_stop_startVM(self): """ Validate that regular user is allowed to stop and start existing VMs that are running in a disabled cluster """ self.vm_user.stop(self.user_apiclient) listResp = VirtualMachine.list(self.user_apiclient, id=self.vm_user.id) self.assertEqual(listResp[0].state, VirtualMachine.STOPPED, "Regular user is not able to Stop Vm in a disabled Cluster! ") self.vm_user.start(self.user_apiclient) listResp = VirtualMachine.list(self.user_apiclient, id=self.vm_user.id) self.assertEqual(listResp[0].state, VirtualMachine.RUNNING, "Regular is not able to Stop Vm in a disabled Cluster! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_36_enableCluster(self): """ Enable Cluster that is disabled Validate that listClusters() returns the allocationstate as "Enabled" """ self.debug("Cluster to be enabled: " + self.cluster.id) clusterupdResp = self.cluster.update(self.apiclient, allocationstate="Enabled", id=self.cluster.id) self.assertEqual(clusterupdResp.allocationstate, "Enabled", "Enabling Cluster did not set the alloctionstate to Enabled") clusterlistResp = Cluster.list(self.apiclient, id=self.cluster.id) self.assertEqual(clusterlistResp[0].allocationstate, "Enabled", "Enabling Cluster did not set the alloctionstate to Enabled") ## Test cases relating to disabling and enabling host @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_41_disableHost(self): """ Disable Host Validate that listHosts() returns the allocationstate as "Disabled" """ self.debug("Host to be disabled: " + self.host.id) hostupdResp = Host.update(self.apiclient, id=self.host.id, allocationstate="Disable") self.assertEqual(hostupdResp.resourcestate, "Disabled", "Disabling Host did not set the alloctionstate to Disabled") hostlistResp = Host.list(self.apiclient, id=self.host.id) self.assertEqual(hostlistResp[0].resourcestate, "Disabled", "Disabling Host did not set the alloctionstate to Disabled") # was tags=["advanced"] @attr("disruptive", "simulator_only", tags=["TODO"], required_hardware="false") def test_42_disableHost_admin_deployVM(self): """ Validate that admin is allowed to deploy VM in a disabled host by passing hostId parameter """ vm = VirtualMachine.create( self.admin_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id, hostid=self.host.id ) self.assertEqual(vm.state, "Running", "Admin is not able to deploy Vm in a disabled Host! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_43_disableHost_admin_deployVM(self): """ Validate that admin is allowed to deploy VM in a disabled host without passing hostId parameter """ try: vm = VirtualMachine.create( self.admin_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id ) except Exception: raise self.fail("Failed to deploy VM, this issue was hit: https://issues.apache.org/jira/browse/CLOUDSTACK-7735") self.assertEqual(vm.state, "Running", "Admin is not able to deploy Vm in a disabled Host! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_44_disableHost_admin_stop_startVM(self): """ Validate that admin is allowed to stop and start existing VMs running in a disabled host """ self.vm_admin.stop(self.admin_apiclient) listResp = VirtualMachine.list(self.apiclient, id=self.vm_admin.id) self.assertEqual(listResp[0].state, VirtualMachine.STOPPED, "Admin is not able to Stop Vm in a disabled Host! ") try: self.vm_admin.start(self.admin_apiclient) except Exception: raise self.fail("Failed to deploy VM, this issue was hit: https://issues.apache.org/jira/browse/CLOUDSTACK-7735") listResp = VirtualMachine.list(self.apiclient, id=self.vm_admin.id) self.assertEqual(listResp[0].state, VirtualMachine.RUNNING, "Admin is not able to Stop Vm in a disabled Host! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_45_disableHost_user_deployVM(self): """ Validate that regular user is not allowed to deploy VM in a disabled host """ try: vm = VirtualMachine.create( self.user_apiclient, {}, zoneid=self.zone.id, serviceofferingid=self.serviceOffering.id, templateid=self.template.id ) self.fail("Regular user is allowed to deploy VM in a host that is disabled") except Exception as e: self.debug("Exception thrown when deploying Virtual Machine on a disabled host - %s" % e) # was tags=["advanced"] @attr("disruptive", "simulator_only", tags=["TODO"], required_hardware="false") def test_46_disableHost_user_stop_startVM(self): """ Validate that regular user is allowed to stop and start existing VMs running in a disabled host """ self.vm_user.stop(self.user_apiclient) listResp = VirtualMachine.list(self.user_apiclient, id=self.vm_user.id) self.assertEqual(listResp[0].state, VirtualMachine.STOPPED, "Regular user is not able to Stop Vm in a disabled Host! ") try: self.vm_user.start(self.user_apiclient) except Exception: raise self.fail("Failed to deploy VM, this issue was hit: https://issues.apache.org/jira/browse/CLOUDSTACK-7735") listResp = VirtualMachine.list(self.user_apiclient, id=self.vm_user.id) self.assertEqual(listResp[0].state, VirtualMachine.RUNNING, "Regular is not able to Stop Vm in a disabled Host! ") @attr("disruptive", "simulator_only", tags=["advanced"], required_hardware="false") def test_47_enableHost(self): """ Enable Host that is disabled Validate that listHosts() returns the allocationstate as "Enabled" """ self.debug("Host to be enabled: " + self.host.id) hostupdResp = Host.update(self.apiclient, id=self.host.id, allocationstate="Enable") self.assertEqual(hostupdResp.resourcestate, "Enabled", "Enabling Host did not set the alloctionstate to Enabled") hostlistResp = Host.list(self.apiclient, id=self.host.id) self.assertEqual(hostlistResp[0].resourcestate, "Enabled", "Enabling Host did not set the alloctionstate to Enabled")