CLOUDSTACK-7732-[Automation] - Automate organization States Test Cases relating to enabling/disabling of zone,pod,host and cluster.

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")
+
+