mirror of
https://github.com/apache/cloudstack.git
synced 2025-11-04 00:02:37 +01:00
633 lines
23 KiB
Python
633 lines
23 KiB
Python
# 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")
|
|
|
|
|