Repository: cloudstack Updated Branches: refs/heads/master ebd42a843 -> 50bf7496e
CLOUDSTACK-7732-[Automation] - Automate organization States Test Cases relating to enabling/disabling of zone,pod,host and cluster. Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/50bf7496 Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/50bf7496 Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/50bf7496 Branch: refs/heads/master Commit: 50bf7496e321eeeadee06cedcd5b6c1195d8485b Parents: ebd42a8 Author: Sangeetha Hariharan <sangeetha.hariha...@citrix.com> Authored: Wed Oct 15 16:44:41 2014 -0700 Committer: Sangeetha Hariharan <sangeetha.hariha...@citrix.com> Committed: Fri Nov 21 12:32:14 2014 -0800 ---------------------------------------------------------------------- .../component/test_organization_states.py | 632 +++++++++++++++++++ 1 file changed, 632 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cloudstack/blob/50bf7496/test/integration/component/test_organization_states.py ---------------------------------------------------------------------- diff --git a/test/integration/component/test_organization_states.py b/test/integration/component/test_organization_states.py new file mode 100644 index 0000000..ffdd08d --- /dev/null +++ b/test/integration/component/test_organization_states.py @@ -0,0 +1,632 @@ +# 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 Local Modules +import marvin +from marvin.cloudstackTestCase import * +from marvin.cloudstackAPI import * +from marvin.lib.utils import * +from marvin.lib.base import * +from marvin.lib.common import * +from marvin.cloudstackException import CloudstackAclException +from nose.plugins.attrib import attr +#Import System modules +import time +import traceback + + +_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 diabled + 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") + + 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 diabled + 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") + + 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 + + @attr("disruptive","simulator_only",tags=["advanced"],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") + + 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") + + + @attr("disruptive","simulator_only",tags=["advanced"],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 diabled + 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") + + 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") + + + @attr("disruptive","simulator_only",tags=["advanced"],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 + """ + 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 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! ") + + 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 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) + + + @attr("disruptive","simulator_only",tags=["advanced"],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! ") + + 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 Host! ") + + @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false") + def test_47_enableHost(self): + """ + Enable Host that is diabled + 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") + +
