apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity
cloudstack/test/integration/component/test_add_remove_network.py
John Bampton 7d23a0a759
Fix spelling (#6272)
2022-07-05 09:08:53 +02:00

2035 lines
87 KiB
Python
Raw Blame History

# 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.
"""
P1 tests for Add Remove Network to VM
Test Plan: https://cwiki.apache.org/confluence/display/CLOUDSTACK/Add+Remove+networks+to+VM+Test+cases
Issue Link: https://issues.apache.org/jira/browse/CLOUDSTACK-645
Feature Specifications: https://cwiki.apache.org/confluence/display/CLOUDSTACK/Add+Remove+Networks+to+VMs
"""
import random
import time
import unittest
from ddt import ddt, data
from marvin.cloudstackAPI import (addNicToVirtualMachine,
removeNicFromVirtualMachine,
updateDefaultNicForVirtualMachine)
from marvin.cloudstackTestCase import cloudstackTestCase
from marvin.codes import PASS
from marvin.lib.base import (
Account,
Domain,
ServiceOffering,
VirtualMachine,
NetworkOffering,
Network,
VpcOffering,
VPC,
PublicIPAddress,
FireWallRule,
NATRule
)
from marvin.lib.common import (get_domain,
get_zone,
get_template,
list_virtual_machines,
list_events,
list_zones,
get_free_vlan,
update_resource_limit,
list_nat_rules
)
from marvin.lib.utils import (validateList,
random_gen,
get_hypervisor_type)
# Import Local Modules
from nose.plugins.attrib import attr
class Services:
"""Test Add Remove Network Services
"""
def __init__(self):
self.services = {
"sleep": 60,
"ostype": "CentOS 5.3 (64-bit)",
# Cent OS 5.3 (64 bit)
"isolated_network_offering": {
"name": 'Test Isolated Network offering',
"displaytext": 'Test Isolated Network offering',
"guestiptype": 'Isolated',
"supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
"traffictype": 'GUEST',
"availability": 'Optional',
"serviceProviderList": {
"Dhcp": 'VirtualRouter',
"Dns": 'VirtualRouter',
"SourceNat": 'VirtualRouter',
"PortForwarding": 'VirtualRouter',
},
},
"shared_network_offering": {
"name": 'Test Shared Network Offering',
"displaytext": 'Test Shared Network Offering',
"guestiptype": 'Shared',
"supportedservices": 'Dhcp,Dns,UserData',
"specifyVlan": "True",
"specifyIpRanges": "True",
"traffictype": 'GUEST',
"serviceProviderList": {
"Dhcp": 'VirtualRouter',
"Dns": 'VirtualRouter',
"UserData": 'VirtualRouter'
},
},
"shared_network": {
"name": "Test Shared Network",
"displaytext": "Test Shared Network",
"gateway": "172.16.17.1",
"netmask": "255.255.255.0",
"startip": "172.16.17.2",
"endip": "172.16.17.20",
},
"shared_network_2": {
"name": "Test Shared Network",
"displaytext": "Test Shared Network",
"gateway": "172.16.18.1",
"netmask": "255.255.255.0",
"startip": "172.16.18.2",
"endip": "172.16.18.20",
},
"isolated_network": {
"name": "Test Isolated Network",
"displaytext": "Test Isolated Network",
},
"service_offering": {
"name": "Tiny Instance",
"displaytext": "Tiny Instance",
"cpunumber": 1,
"cpuspeed": 100,
# in MHz
"memory": 256,
# In MBs
},
"account": {
"email": "test@test.com",
"firstname": "Test_add_remove_network_vm",
"lastname": "User",
"username": "test_add_remove_network_vm",
"password": "password",
},
"domain": {
"name": "Domain_add_nw_to_vm",
},
"virtual_machine": {
"displayname": "testserver",
"username": "root", # VM creds for SSH
"password": "password",
"ssh_port": 22,
"hypervisor": 'XenServer',
"privateport": 22,
"publicport": 22,
"protocol": 'TCP',
},
"vpc_offering": {
"name": 'VPC off add remove network',
"displaytext": 'VPC off add remove network',
"supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL',
},
"vpc": {
"name": "TestVPC add remove network",
"displaytext": "TestVPC add remove network",
"cidr": '10.0.0.1/24'
},
"natrule": {
"privateport": 22,
"publicport": 22,
"protocol": "TCP"
},
}
@ddt
class TestAddNetworkToVirtualMachine(cloudstackTestCase):
@classmethod
def setUpClass(cls):
cls.testClient = super(TestAddNetworkToVirtualMachine, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
hypervisor = get_hypervisor_type(cls.api_client)
if hypervisor.lower() not in ["xenserver", "kvm"]:
raise unittest.SkipTest("This feature is supported only on XenServer and KVM")
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
# Set Zones and disk offerings
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = template.id
# Create Accounts & networks
cls.services["isolated_network"]["zoneid"] = cls.zone.id
cls.services["shared_network"]["zoneid"] = cls.zone.id
cls._cleanup = []
cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.virtual_machine = VirtualMachine.create(cls.api_client, cls.services["virtual_machine"], accountid=cls.account.name,
domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id,
mode=cls.zone.networktype)
cls._cleanup.append(cls.virtual_machine)
cls.defaultNetworkId = cls.virtual_machine.nic[0].networkid
cls.isolated_network_offering = NetworkOffering.create(cls.api_client, cls.services["isolated_network_offering"])
cls._cleanup.append(cls.isolated_network_offering)
cls.isolated_network_offering.update(cls.api_client, state='Enabled')
cls.shared_network_offering = NetworkOffering.create(cls.api_client, cls.services["shared_network_offering"])
cls._cleanup.append(cls.shared_network_offering)
cls.shared_network_offering.update(cls.api_client, state='Enabled')
cls.isolated_network = Network.create(cls.api_client, cls.services["isolated_network"], cls.account.name,
cls.account.domainid, networkofferingid=cls.isolated_network_offering.id)
cls._cleanup.append(cls.isolated_network)
cls.services["shared_network"]["vlan"] = get_free_vlan(cls.api_client, cls.zone.id)[1]
shared_network_subnet_number = random.randrange(1, 254)
cls.services["shared_network"]["gateway"] = "172.16." + str(shared_network_subnet_number) + ".1"
cls.services["shared_network"]["startip"] = "172.16." + str(shared_network_subnet_number) + ".2"
cls.services["shared_network"]["endip"] = "172.16." + str(shared_network_subnet_number) + ".20"
cls.shared_nw_endip = cls.services["shared_network"]["endip"]
cls.shared_network = Network.create(cls.api_client, cls.services["shared_network"], cls.account.name,
cls.account.domainid, networkofferingid=cls.shared_network_offering.id)
cls._cleanup.append(cls.shared_network)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.addednics = []
shared_network_subnet_number = random.randrange(1, 254)
self.services["shared_network"]["gateway"] = "172.16." + str(shared_network_subnet_number) + ".1"
self.services["shared_network"]["startip"] = "172.16." + str(shared_network_subnet_number) + ".2"
self.services["shared_network"]["endip"] = "172.16." + str(shared_network_subnet_number) + ".20"
self.services["shared_network_2"]["gateway"] = "172.16." + str(shared_network_subnet_number + 1) + ".1"
self.services["shared_network_2"]["startip"] = "172.16." + str(shared_network_subnet_number + 1) + ".2"
self.services["shared_network_2"]["endip"] = "172.16." + str(shared_network_subnet_number + 1) + ".20"
self.cleanup = []
def tearDown(self):
try:
for nic in self.addednics:
self.virtual_machine.remove_nic(self.apiclient, nic.id)
except Exception as e:
self.debug("Exception during removal of nics : %s" % e)
super(TestAddNetworkToVirtualMachine, self).tearDown()
@classmethod
def tearDownClass(cls):
try:
# Disable Network Offerings
cls.isolated_network_offering.update(cls.api_client, state='Disabled')
cls.shared_network_offering.update(cls.api_client, state='Disabled')
except Exception as e:
cls.debug("Exception during disable of networks : %s" % e)
super(TestAddNetworkToVirtualMachine, cls).tearDownClass()
def addNetworkToVm(self, network, vm, ipaddress=None):
"""Add network to VM and check if new nic added in the VM"""
self.debug("Adding %s Network: %s to virtual machine %s" %
(network.type, network.id, vm.id))
vm.add_nic(self.apiclient, network.id, ipaddress=ipaddress)
vm_list = list_virtual_machines(self.apiclient, id=vm.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
self.debug("virtual machine nics: %s" % vm_list[0].nic)
nics = [x for x in vm_list[0].nic if x.networkid == network.id]
self.debug("Filtered nics list: %s:" % nics)
# Only the nics added to self.virtual_machine should be added to this list
# Nics added to their list are removed before execution of next test case because we are using
# same virtual machine in all test cases, so it is important that the common
# virtual machine should contain only the default nic whenever new test case
# execution starts
if vm.id == self.virtual_machine.id:
self.addednics.append(nics[-1])
self.assertTrue(len(nics) == 1, "nics list should contain the nic of added isolated network,\
the number of nics for the network should be 1, instead they are %s" %
len(nics))
if ipaddress is not None:
self.assertEqual(nics[0].ipaddress, ipaddress, "The ip address of nic does not match with \
the ip address passed while adding network to vm. ip address of nic is %s \
while passed ip address is %s" % (nics[0].ipaddress, ipaddress))
return
@attr(tags=["advanced", "dvs"])
@data("isolated", "shared")
def test_01_add_nw_running_vm(self, value):
"""Add network to running VM"""
# 1. Deploy VM in an account
# 2. Add isolated/shared network to the VM which is in running state
# Validate the following:
# 1. New nic is generated for the added network
# 2. Event NIC.CREATE is generated
network = None # The network which we are adding to the vm
if value == "isolated":
network = self.isolated_network
elif value == "shared":
network = self.shared_network
if network is None:
self.skipTest("Network should not be none. Case not handled for Network of type %s" % value)
self.addNetworkToVm(network, self.virtual_machine)
self.debug("Retrieving the list of events matching 'NIC.CREATE' in account: %s" % self.account.name)
events = list_events(self.apiclient, account=self.account.name, domainid=self.account.domainid,
type='NIC.CREATE')
event_list_validation_result = validateList(events)
self.assertEqual(event_list_validation_result[0], PASS, "event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event NIC.CREATE")
return
@attr(tags=["advanced", "dvs"])
@data("isolated", "shared")
def test_02_add_nw_stopped_vm(self, value):
"""Add network to stopped VM"""
# 1. Deploy VM in an account
# 2. Stop the VM
# 3. Add isolated/shared network to the stopped VM
# Validate the following:
# 1. New nic is generated for the added network
try:
self.virtual_machine.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop VM: %s" % e)
network = None # The network which we are adding to the vm
if value == "isolated":
network = self.isolated_network
elif value == "shared":
network = self.shared_network
if network is None:
self.skipTest("Network should not be none. Case not handled for Network of type %s" % value)
self.addNetworkToVm(network, self.virtual_machine)
self.debug("Starting Virtual Machine: %s" % self.virtual_machine.id)
self.virtual_machine.start(self.apiclient)
return
@attr(tags=["advanced", "dvs"])
@data("isolated", "shared")
def test_03_add_nw_multiple_times(self, value):
"""Add same network multiple times to running VM"""
# 1. Deploy VM in an account
# 2. Add isolated/shared network to the VM
# 3. Try Adding same network again to the VM
# Validate the following:
# 1. Adding same network to vm multiple times fails
network = None # The network which we are adding to the vm
if value == "isolated":
network = self.isolated_network
elif value == "shared":
network = self.shared_network
if network is None:
self.skipTest("Network should not be none. Case not handled for Network of type %s" % value)
try:
virtual_machine = VirtualMachine.create(
self.api_client, self.services["virtual_machine"],
accountid=self.account.name, domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype,
networkids=[self.defaultNetworkId])
self.cleanup.append(virtual_machine)
except Exception as e:
self.fail("Failed to deply virtual machine: %s" % e)
# Adding network to vm for the first time
self.addNetworkToVm(network, virtual_machine)
# Trying to add same network to vm for the second time
with self.assertRaises(Exception) as e:
self.addNetworkToVm(network, virtual_machine)
self.debug("Adding same network again failed with exception: %s" % e.exception)
return
@attr(tags=["advanced", "dvs"])
@data("isolated")
def test_04_vpc_nw_running_vm(self, value):
"""Add VPC network to running VM belonging to isolated network"""
# 1. Deploy VM in an account
# 2. Add isolated network to the VM
# 3. Create VPC
# 4. Try adding VPC to the VM
# Validate the following:
# 1. Adding VPC to vm should fail
try:
virtual_machine = VirtualMachine.create(
self.api_client, self.services["virtual_machine"],
accountid=self.account.name, domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype,
networkids=[self.defaultNetworkId])
self.cleanup.append(virtual_machine)
except Exception as e:
self.fail("Failed to deply virtual machine: %s" % e)
network = self.isolated_network
self.addNetworkToVm(network, virtual_machine)
self.debug("Creating VPC offering")
vpc_off = VpcOffering.create(self.api_client, self.services["vpc_offering"])
self.cleanup.append(vpc_off)
self.debug("Created VPC offering: %s" % vpc_off.id)
self.debug("Enabling the VPC offering")
vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating VPC")
vpc = VPC.create(self.apiclient, self.services["vpc"], vpcofferingid=vpc_off.id, zoneid=self.zone.id,
account=self.account.name, domainid=self.account.domainid)
self.cleanup.append(vpc)
self.debug("Trying to add VPC to vm belonging to isolated network, this should fail")
with self.assertRaises(Exception):
virtual_machine.add_nic(self.apiclient, vpc.id)
self.debug("Disabling vpc offering: %s" % vpc_off.id)
vpc_off.update(self.apiclient, state='Disabled')
return
@attr(tags=["advanced", "dvs"])
@data("isolated")
def test_05_add_vpc_nw_stopped_vm(self, value):
"""Add VPC network to stopped VM belonging to isolated network"""
# 1. Deploy VM in an account
# 2. Stop the VM
# 3. Add isolated network to the VM
# 4. Create VPC
# 5. Try adding VPC to the stopped VM
# Validate the following:
# 1. Adding VPC to vm should fail
try:
self.virtual_machine.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop virtual machine: %s" % e)
self.addNetworkToVm(self.isolated_network, self.virtual_machine)
self.debug("Creating VPC offering")
vpc_off = VpcOffering.create(self.api_client, self.services["vpc_offering"])
self.cleanup.append(vpc_off)
self.debug("Created VPC offering: %s" % vpc_off.id)
self.debug("Enabling the VPC offering")
vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating VPC")
vpc = VPC.create(self.apiclient, self.services["vpc"], vpcofferingid=vpc_off.id, zoneid=self.zone.id,
account=self.account.name, domainid=self.account.domainid)
self.cleanup.append(vpc)
self.debug("Trying to add VPC to vm belonging to isolated network, this should fail")
with self.assertRaises(Exception):
self.virtual_machine.add_nic(self.apiclient, vpc.id)
self.debug("Starting virtual machine")
self.virtual_machine.start(self.apiclient)
self.debug("Disabling vpc offering: %s" % vpc_off.id)
vpc_off.update(self.apiclient, state='Disabled')
return
@attr(tags=["advanced", "dvs"])
def test_06_add_nw_ipaddress_running_vm(self):
"""Add network and ip address to running VM"""
# 1. Deploy VM in an account
# 2. Add shared network and ip address to this VM
# Validate the following:
# 1. New nic gets added for the shared network
# 2. The newly added nic has the ip address same as
# that passed while adding the network
try:
virtual_machine = VirtualMachine.create(
self.api_client, self.services["virtual_machine"],
accountid=self.account.name, domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype,
networkids=[self.defaultNetworkId])
self.cleanup.append(virtual_machine)
except Exception as e:
self.fail("Failed to deply virtual machine: %s" % e)
ipaddress = self.shared_nw_endip
self.debug("Adding network to vm with ip address %s: " % ipaddress)
self.addNetworkToVm(self.shared_network, virtual_machine, ipaddress=ipaddress)
return
@attr(tags=["advanced", "dvs"])
def test_10_add_nw_invalid_ipaddress_running_vm(self):
"""Add network with invalid ip address to running VM"""
# 1. Deploy VM in an account
# 2. Add shared network with invalid ip address to this VM
# Validate the following:
# 1. Adding network to VM should fail because of invalid ip address
ipaddress = "257.257.257.257" # Invalid ip address
self.debug("Adding network to vm with ip address %s: " % ipaddress)
with self.assertRaises(Exception) as e:
self.addNetworkToVm(self.shared_network, self.virtual_machine,
ipaddress=ipaddress)
self.debug("API failed with exception: %s" % e.exception)
return
# was tags=["advanced", "dvs"],
# the apiclient that is being used to test this has to much rights?
@attr(tags=["TODO"])
@data("isolated", "shared")
def test_14_add_nw_different_account(self, value):
"""Add network to running VM"""
# 1. Deploy VM in an account
# 2. Create new account under same domain and create network in that account
# 3. Add isolated/shared network belonging to other account to the VM in first account
# Validate the following:
# 1. Adding network should fail
network = None # The network which we are adding to the vm
account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id)
self.cleanup.append(account)
if value == "isolated":
network = Network.create(self.api_client, self.services["isolated_network"], account.name,
account.domainid, networkofferingid=self.isolated_network_offering.id)
self.cleanup.append(network)
elif value == "shared":
self.services["shared_network_2"]["zoneid"] = self.zone.id
self.services["shared_network_2"]["vlan"] = get_free_vlan(self.apiclient, self.zone.id)[1]
network = Network.create(self.api_client, self.services["shared_network_2"], account.name,
account.domainid, networkofferingid=self.shared_network_offering.id)
self.cleanup.append(network)
if network is None:
self.skipTest("Network should not be none. Case not handled for Network of type %s" % value)
self.debug("Trying to %s network in account %s to a vm in account %s, This should fail" %
(network.type, account.name, self.account.name))
try:
vm_with_nic = self.virtual_machine.add_nic(self.apiclient, network.id)
nics = [x for x in vm_with_nic.nic if x.networkid == network.id]
self.addednics.append(nics[-1])
except Exception:
pass
else:
self.fail("User was able to add NIC, test failed! This issue has been hit: CLOUDSTACK-10071")
return
@attr(tags=["advanced", "dvs"])
def test_24_add_nw_different_domain(self):
"""Add network to running VM"""
# 1. Create two domains
# 2. Create network in one domain and create virtual machine in other domain
# 3. Ad isolated/shared network belonging to one domain to the vm belonging to other domain
# Validate the following:
# 1. Adding network should fail
network = None # The network which we are adding to the vm
try:
self.child_domain_1 = Domain.create(self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.cleanup.append(self.child_domain_1)
self.child_do_admin_1 = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain_1.id
)
self.cleanup.append(self.child_do_admin_1)
self.child_domain_2 = Domain.create(self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.cleanup.append(self.child_domain_2)
self.child_do_admin_2 = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain_2.id)
self.cleanup.append(self.child_do_admin_2)
except Exception as e:
self.fail(e)
network = Network.create(self.api_client, self.services["isolated_network"], self.child_do_admin_1.name,
self.child_do_admin_1.domainid, networkofferingid=self.isolated_network_offering.id)
self.cleanup.append(network)
virtual_machine = VirtualMachine.create(self.apiclient, self.services["virtual_machine"], accountid=self.child_do_admin_2.name,
domainid=self.child_do_admin_2.domainid, serviceofferingid=self.service_offering.id,
mode=self.zone.networktype)
self.cleanup.append(virtual_machine)
time.sleep(self.services["sleep"])
self.debug("Trying to %s network in domain %s to a vm in domain %s, This should fail" %
(network.type, self.child_domain_1.name, self.child_domain_2.name))
with self.assertRaises(Exception) as e:
virtual_machine.add_nic(self.apiclient, network.id)
self.debug("Operation failed with exception %s" % e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_25_add_nw_above_account_limit(self):
"""Add network to VM with maximum network limit reached"""
# 1. Create an account and create maximum allowed networks in the account
# 2. Deploy VM in this account
# 3. Create a network in other account and add to this VM
# Validate the following:
# 1. Adding network should fail
self.debug("Creating account 1")
account_1 = Account.create(
self.apiclient,
self.services["account"],
domainid=self.domain.id
)
self.cleanup.append(account_1)
self.debug("setting network limit of account: %s as 1" % account_1.name)
update_resource_limit(
self.apiclient,
6, # Network
max=1,
account=account_1.name,
domainid=account_1.domainid
)
self.debug("Creating isolated network in account: %s" % account_1.name)
network_1 = Network.create(self.api_client, self.services["isolated_network"], account_1.name,
account_1.domainid, networkofferingid=self.isolated_network_offering.id)
self.cleanup.append(network_1)
self.debug("created network %s" % network_1.name)
self.debug("Deploying virtual machine in account: %s" % account_1.name)
virtual_machine = VirtualMachine.create(self.apiclient, self.services["virtual_machine"], accountid=account_1.name,
domainid=account_1.domainid, serviceofferingid=self.service_offering.id,
mode=self.zone.networktype)
self.cleanup.append(virtual_machine)
self.debug("Deployed virtual machine : %s" % virtual_machine.id)
self.debug("Creating another account")
account_2 = Account.create(
self.apiclient,
self.services["account"],
domainid=self.domain.id
)
self.cleanup.append(account_2)
self.debug("Created account %s" % account_2.name)
self.debug("Creating network in account %s" % account_2.name)
network_2 = Network.create(self.api_client, self.services["isolated_network"], account_2.name,
account_2.domainid, networkofferingid=self.isolated_network_offering.id)
self.cleanup.append(network_2)
self.debug("Created network %s" % network_2.name)
self.debug("Trying to add netwrok %s to VM %s, this should fail" %
(network_2.name, virtual_machine.id))
with self.assertRaises(Exception) as e:
virtual_machine.add_nic(self.apiclient, network_2.id)
self.debug("Operation failed with exception %s" % e.exception)
return
class TestRemoveNetworkFromVirtualMachine(cloudstackTestCase):
@classmethod
def setUpClass(cls):
cls.testClient = super(TestRemoveNetworkFromVirtualMachine, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
hypervisor = get_hypervisor_type(cls.api_client)
if hypervisor.lower() not in ["xenserver", "kvm"]:
raise unittest.SkipTest("This feature is supported only on XenServer and KVM")
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
# Set Zones and disk offerings
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = template.id
# Create Accounts & networks
cls.services["isolated_network"]["zoneid"] = cls.zone.id
cls.services["shared_network"]["zoneid"] = cls.zone.id
cls._cleanup = []
cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.virtual_machine = VirtualMachine.create(cls.api_client, cls.services["virtual_machine"], accountid=cls.account.name,
domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id,
mode=cls.zone.networktype)
cls._cleanup.append(cls.virtual_machine)
# Create Shared Network Offering
cls.isolated_network_offering = NetworkOffering.create(cls.api_client, cls.services["isolated_network_offering"])
cls._cleanup.append(cls.isolated_network_offering)
# Enable Isolated Network offering
cls.isolated_network_offering.update(cls.api_client, state='Enabled')
cls.isolated_network = Network.create(cls.api_client, cls.services["isolated_network"], cls.account.name,
cls.account.domainid, networkofferingid=cls.isolated_network_offering.id)
cls._cleanup.append(cls.isolated_network)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
self.addednics = []
def tearDown(self):
try:
for nic in self.addednics:
self.virtual_machine.remove_nic(self.apiclient, nic.id)
except Exception as e:
self.debug("Exception during removal of nics : %s" % e)
super(TestRemoveNetworkFromVirtualMachine, self).tearDown()
@classmethod
def tearDownClass(cls):
try:
cls.isolated_network_offering.update(cls.api_client, state='Disabled')
except Exception as e:
cls.debug("Exception during disabling network offering : %s" % e)
super(TestRemoveNetworkFromVirtualMachine, cls).tearDownClass()
def addNetworkToVm(self, network, vm):
"""Add network to VM and check if new nic added in the VM"""
self.debug("Adding %s Network: %s to virtual machine %s" %
(network.type, network.id, vm.id))
vm.add_nic(self.apiclient, network.id)
vm_list = list_virtual_machines(self.apiclient, id=vm.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
self.debug("virtual machine nics: %s" % vm_list[0].nic)
# Add nic of network to list so that it can be deleted later accessing its id from this list
self.nics = [x for x in vm_list[0].nic if x.networkid == network.id]
self.debug("Filtered nics list: %s:" % self.nics)
self.assertTrue(len(self.nics) == 1, "nics list should contain the nic of added isolated network,\
the number of nics for the network should be 1, instead they are %s" %
len(self.nics))
return self.nics
@attr(tags=["advanced", "dvs"])
def test_07_remove_nic_running_vm(self):
"""Remove nic from running VM"""
# 1. Deploy Vm in account
# 2. Add network to VM
# 3. Remove the nic added by the newly added network
# Validate the following:
# 1. Newly added nic is removed
# 2. Event NIC.DELETE is generated
self.addNetworkToVm(self.isolated_network, self.virtual_machine)
# Access the nic of the added network from self.nics object which is fillled
# in addNetworkToVm function
self.debug("Removing added nic %s from vm %s" %
(self.nics[0].id, self.virtual_machine.id))
self.virtual_machine.remove_nic(self.apiclient, self.nics[0].id)
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
self.debug("virtual machine nics: %s" % vm_list[0].nic)
# Verify the nic is removed from the virtual machine
self.debug("Verifying the nic is removed from the virtual machine")
self.assertFalse(any(x.networkid == self.isolated_network.id for x in vm_list[0].nic),
"nic still present in the virtual machine nic list")
self.debug("nic removed successfully")
self.debug("Retrieving events list matching events 'NIC.DELETE'")
events = list_events(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='NIC.DELETE'
)
event_list_validation_result = validateList(events)
self.assertEqual(event_list_validation_result[0], PASS, "vm list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event NIC.DELETE")
self.debug("events: %s" % events)
return
@attr(tags=["advanced", "dvs"])
def test_08_remove_default_nic(self):
"""Test Remove default nic of running VM"""
# 1. Deploy Vm in account
# 2. Try to remove the default nic of the VM
# Validate the following:
# 1. Default nic of vm is not removed
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
self.debug("virtual machine nics: %s" % vm_list[0].nic)
self.assertEqual(len(vm_list[0].nic), 1, "There should only be default nic present in the vm")
self.debug("Trying to remove the default nic of vm : %s, this should fail" %
self.virtual_machine.id)
with self.assertRaises(Exception):
self.virtual_machine.remove_nic(self.apiclient, vm_list[0].nic[0].id)
self.debug("Removing default nic of vm failed")
return
@attr(tags=["advanced", "dvs"])
def test_09_remove_foreign_nic(self):
"""Remove nic which does not belong to VM"""
# 1. Add VM in an account
# 1. Add new account and deploy vm in it
# 2. Try to remove nic of the new vm from first vm
# Validate the following:
# 1. Nic remove operation should fail
self.debug("Creating new account")
account = Account.create(
self.api_client,
self.services["account"],
domainid=self.domain.id
)
self.cleanup.append(account)
self.debug("created new account : %s" % account.name)
self.debug("Deploying virtual machine in this account")
virtual_machine = VirtualMachine.create(self.apiclient, self.services["virtual_machine"], accountid=account.name,
domainid=account.domainid, serviceofferingid=self.service_offering.id,
mode=self.zone.networktype)
self.debug("Deployed virtual machine: %s" % virtual_machine.id)
self.debug("Trying to remove nic of new virtual machine from existing virtual machine, This \
operation should fail")
with self.assertRaises(Exception) as e:
self.virtual_machine.remove_nic(self.apiclient, virtual_machine.nic[0].id)
self.debug("Operation failed with exception: %s" % e.exception)
return
@attr(tags=["advanced"], required_hardware="true")
def test_29_remove_nic_CS22503(self):
"""Test to verify remove nic from vm if the nic ip is same as another vm ip in another network"""
# 1. Deploy vm v1 with networks n1 and n2
# 2. Check the ip address of nic in n2 say ip1
# 3. Deployed vm v2 in another network say n3 with same IP address as ip1 using
# 'deployVirtualMachine' api with 'ipaddress' as one of the parameters.
# 4. Acquire public IP in n3 network.
# 5. Configure PF on the acquired IP and assign it to vm v2
# 6. Try to remove nic n2 from v1. Should be successful
# There was a bug due to both vms has same ip address, so not allowing to remove nic
vm1 = self.virtual_machine
nic2 = self.addNetworkToVm(self.isolated_network, vm1)
self.addednics.append(nic2)
# get the ip address of the nic added in 2nd network
vm1_ip = nic2[0].ipaddress
self.assertIsNotNone(vm1_ip, "New nic did not get the ip address")
# Create network n3
self.network3 = Network.create(
self.api_client,
self.services["isolated_network"],
self.account.name,
self.account.domainid,
networkofferingid=self.isolated_network_offering.id
)
self.cleanup.append(self.network3)
self.vm2 = VirtualMachine.create(
self.api_client,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[self.network3.id],
ipaddress=vm1_ip,
mode=self.zone.networktype
)
self.cleanup.append(self.vm2)
vm2 = VirtualMachine.list(
self.api_client,
id=self.vm2.id
)
self.assertEqual(validateList(vm2)[0], PASS, "list vms returned invalid response")
self.assertIsNotNone(vm2[0].nic[0].ipaddress, "vm2 didn't get the ip address")
self.assertEqual(
vm1_ip,
vm2[0].nic[0].ipaddress,
"vm2 did not get the ip address passed while deploying vm"
)
ip_address = PublicIPAddress.create(
self.apiclient,
self.account.name,
self.zone.id,
self.account.domainid,
self.services["virtual_machine"],
self.network3.id
)
self.cleanup.append(ip_address)
# Open up firewall port for SSH
FireWallRule.create(
self.apiclient,
ipaddressid=ip_address.ipaddress.id,
protocol=self.services["natrule"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule"]["publicport"],
endport=self.services["natrule"]["publicport"]
)
# Create NAT rule
nat_rule = NATRule.create(
self.apiclient,
self.vm2,
self.services["natrule"],
ip_address.ipaddress.id
)
list_nat_rule_response = list_nat_rules(
self.apiclient,
id=nat_rule.id
)
self.assertEqual(
validateList(list_nat_rule_response)[0],
PASS,
"Check list response returns a valid list"
)
self.assertEqual(
list_nat_rule_response[0].id,
nat_rule.id,
"Check Correct Port forwarding Rule is returned"
)
# Try to remove nic 2 from vm1
try:
vm1.remove_nic(self.apiclient, self.nics[0].id)
vm1_res = VirtualMachine.list(self.apiclient, id=vm1.id)
self.assertEqual(validateList(vm1_res)[0], PASS, "invalid listvm response")
self.assertEqual(
len(vm1_res[0].nic),
1,
"VM has more than one nic even after removing the 2nd nic"
)
except Exception as e:
self.fail("Failed to delete the nic from vm")
return
@attr(tags=["advanced"], required_hardware="true")
def test_30_remove_nic_reattach(self):
"""
Test to verify vm start after NIC removal and reattach
# 1.Create vm which has 3 nics(e.g. #0,#1,#2)
# 2.Stop the vm
# 3.Remove second nic(#1)
# 4.Add/Reattach same network(#1)
# 5.Start the instance
"""
self.ntwk2 = Network.create(
self.apiclient,
self.services["isolated_network"],
self.account.name,
self.account.domainid,
networkofferingid=self.isolated_network_offering.id
)
self.cleanup.append(self.ntwk2)
self.ntwk3 = Network.create(
self.apiclient,
self.services["isolated_network"],
self.account.name,
self.account.domainid,
networkofferingid=self.isolated_network_offering.id
)
self.cleanup.append(self.ntwk3)
self.test_vm = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype,
networkids=[self.isolated_network.id, self.ntwk2.id, self.ntwk3.id]
)
self.cleanup.append(self.test_vm)
self.assertIsNotNone(self.test_vm, "Failed to create vm with 3 nics")
vm_res = VirtualMachine.list(
self.apiclient,
id=self.test_vm.id
)
self.assertEqual(validateList(vm_res)[0], PASS, "Invalid list vm response")
self.nics = vm_res[0].nic
self.assertEqual(
validateList(self.nics)[0],
PASS,
"vm response does not contain nics info"
)
self.assertEqual(len(self.nics), 3, "Not all nics found in vm response")
self.test_vm.stop(self.apiclient)
vm_res2 = VirtualMachine.list(
self.apiclient,
id=self.test_vm.id
)
self.assertEqual(validateList(vm_res2)[0], PASS, "Invalid response")
self.assertEqual(
vm_res2[0].state,
"Stopped",
"VM did not stop properly"
)
"""
get the network id of the nic which we are remove from the nic, so that we can
use that network id for reattach
"""
nic_to_attach = [x for x in [self.isolated_network, self.ntwk2, self.ntwk3] \
if x.id == self.nics[1].networkid]
self.assertEqual(validateList(nic_to_attach)[0], PASS, "No matching nics")
self.assertEqual(len(nic_to_attach), 1, "More than one nic in same network")
try:
self.test_vm.remove_nic(self.apiclient, nicId=self.nics[1].id)
self.test_vm.add_nic(
self.apiclient,
nic_to_attach[0].id
)
self.test_vm.start(self.apiclient)
except Exception as e:
self.fail("Failed to start vm after nic removal and attachment")
vm_res3 = VirtualMachine.list(self.apiclient, id=self.test_vm.id)
self.assertEqual(
validateList(vm_res3)[0],
PASS,
"Invalid listvm response after nic detach and attach"
)
self.assertEqual(
vm_res3[0].state,
"Running",
"VM didn't come to running state after nic detach and attach"
)
vm_nics = vm_res3[0].nic
self.assertEqual(validateList(vm_nics)[0], PASS, "Invalid nics after vm stop/start")
self.assertEqual(
len(vm_nics),
3,
"Nic is not attached/detected"
)
self.addednics.extend(vm_nics)
return
class TestUpdateVirtualMachineNIC(cloudstackTestCase):
@classmethod
def setUpClass(cls):
cls.testClient = super(TestUpdateVirtualMachineNIC, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
hypervisor = get_hypervisor_type(cls.api_client)
if hypervisor.lower() not in ["xenserver", "kvm"]:
raise unittest.SkipTest("This feature is supported only on XenServer and KVM")
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
# Set Zones and disk offerings
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = template.id
# Create Accounts & networks
cls.services["isolated_network"]["zoneid"] = cls.zone.id
cls.services["shared_network"]["zoneid"] = cls.zone.id
cls._cleanup = []
cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.virtual_machine = VirtualMachine.create(cls.api_client, cls.services["virtual_machine"],
accountid=cls.account.name, domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.zone.networktype)
cls._cleanup.append(cls.virtual_machine)
cls.isolated_network_offering = NetworkOffering.create(cls.api_client, cls.services["isolated_network_offering"])
cls._cleanup.append(cls.isolated_network_offering)
cls.isolated_network_offering.update(cls.api_client, state='Enabled')
cls.isolated_network = Network.create(cls.api_client, cls.services["isolated_network"], cls.account.name,
cls.account.domainid, networkofferingid=cls.isolated_network_offering.id)
cls._cleanup.append(cls.isolated_network)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
self.addednics = []
def tearDown(self):
try:
for nic in self.addednics:
self.virtual_machine.remove_nic(self.apiclient, nic.id)
except Exception as e:
self.debug("Exception during removal of nics : %s" % e)
super(TestUpdateVirtualMachineNIC, self).tearDown()
@classmethod
def tearDownClass(cls):
try:
cls.isolated_network_offering.update(cls.api_client, state='Disabled')
except Exception as e:
cls.debug("Exception during disable of network offering : %s" % e)
super(TestUpdateVirtualMachineNIC, cls).tearDownClass()
def addNetworkToVm(self, network, vm):
"""Add network to VM and check if new nic added in the VM"""
self.debug("Adding %s Network: %s to virtual machine %s" %
(network.type, network.id, vm.id))
vm.add_nic(self.apiclient, network.id)
vm_list = list_virtual_machines(self.apiclient, id=vm.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
self.debug("virtual machine nics: %s" % vm_list[0].nic)
# Add nic of network to list so that it can be deleted later accessing its id from this list
self.nics = [x for x in vm_list[0].nic if x.networkid == network.id]
self.debug("Filtered nics list: %s:" % self.nics)
self.assertTrue(len(self.nics) == 1, "nics list should contain the nic of added isolated network,\
the number of nics for the network should be 1, instead they are %s" %
len(self.nics))
self.addednics.append(self.nics[0])
return
@attr(tags=["advanced", "dvs"])
def test_11_update_nic_running_vm(self):
"""update default nic of running VM"""
# 1. Deploy Vm in account
# 2. Add network to VM
# 3. Update default nic of VM (Make the newly added NIC as default)
# Validate the following:
# 1. Default nic is updated
# 2. Previous default nic is now non-default
# 3. Event NIC.UPDATE is generated
self.addNetworkToVm(self.isolated_network, self.virtual_machine)
self.debug("Listing virtual machine so that to retrive the list of non-default and default nic")
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
if len(vm_list[0].nic) != 2:
self.fail("VM should have exactly two NICs")
defaultNicIdBeforeUpdate = None
nonDefaultNicIdBeforeUpdate = None
for nic in vm_list[0].nic:
if nic.isdefault:
defaultNicIdBeforeUpdate = nic.id
else:
nonDefaultNicIdBeforeUpdate = nic.id
self.debug("Default nic of VM is %s and non default nic of VM is %s"
% (defaultNicIdBeforeUpdate, nonDefaultNicIdBeforeUpdate))
self.debug("Making non default nic as default nic")
self.virtual_machine.update_default_nic(self.apiclient, nicId=nonDefaultNicIdBeforeUpdate)
self.debug("Again listing the NIC list of VM to verify the update operation was successful")
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
if len(vm_list[0].nic) != 2:
self.fail("VM should have exactly two NICs")
for nic in vm_list[0].nic:
if nic.isdefault:
defaultNicIdAfterUpdate = nic.id
self.assertEqual(nonDefaultNicIdBeforeUpdate, defaultNicIdAfterUpdate, "old non default NIC not made\
default one, update_default_nic API failed")
self.debug("Retrieving events list matching events 'NIC.UPDATE'")
events = list_events(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='NIC.UPDATE'
)
event_list_validation_result = validateList(events)
self.assertEqual(event_list_validation_result[0], PASS, "event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event NIC.UPDATE")
self.debug("events: %s" % events)
return
@attr(tags=["advanced", "dvs"])
def test_12_make_default_nic_as_default(self):
"""Try to set default nic of vm again as default"""
# 1. Deploy Vm in account
# 2. Set default nic of vm again as default
# Validate the following:
# 1. updateDefaultNic API fails
self.debug("Listing virtual machine to get default nic")
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
defaultNicId = None
for nic in vm_list[0].nic:
if nic.isdefault:
defaultNicId = nic.id
self.debug("Trying to set default nic again as default nic, This should fail")
with self.assertRaises(Exception) as e:
self.virtual_machine.update_default_nic(self.apiclient, nicId=defaultNicId)
self.debug("updateDefaultNic operation failed as expected with exception: %s" %
e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_13_set_foreign_nic_as_default(self):
"""set nic which does not belong to VM as its default one"""
# 1. Add VM in an account
# 1. Add new account and deploy vm in it
# 2. Try to set nic of the new vm as default nic of first vm
# Validate the following:
# 1. updateDefaultNic operation should fail
self.debug("Creating new account")
account = Account.create(self.api_client, self.services["account"], domainid=self.domain.id)
self.cleanup.append(account)
self.debug("created new account : %s" % account.name)
self.debug("Deploying virtual machine in this account")
virtual_machine = VirtualMachine.create(self.apiclient, self.services["virtual_machine"],
accountid=account.name, domainid=account.domainid,
serviceofferingid=self.service_offering.id, mode=self.zone.networktype)
self.cleanup.append(virtual_machine)
time.sleep(self.services["sleep"])
self.debug("Deployed virtual machine: %s" % virtual_machine.id)
foreignNicId = virtual_machine.nic[0].id
self.debug("Trying to set nic of new virtual machine as default nic of existing virtual machine, This \
operation should fail")
with self.assertRaises(Exception) as e:
self.virtual_machine.update_default_nic(self.apiclient, nicId=foreignNicId)
self.debug("updateDefaultNic operation failed as expected with exception: %s" %
e.exception)
return
class TestFailureScenariosAddNetworkToVM(cloudstackTestCase):
@classmethod
def setUpClass(cls):
cls.testClient = super(TestFailureScenariosAddNetworkToVM, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
hypervisor = get_hypervisor_type(cls.api_client)
if hypervisor.lower() not in ["xenserver", "kvm"]:
raise unittest.SkipTest("This feature is supported only on XenServer and KVM")
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
# Set Zones and disk offerings
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = template.id
# Create Accounts & networks
cls.services["isolated_network"]["zoneid"] = cls.zone.id
cls._cleanup = []
cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.virtual_machine = VirtualMachine.create(cls.api_client, cls.services["virtual_machine"],
accountid=cls.account.name, domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id, mode=cls.zone.networktype)
cls._cleanup.append(cls.virtual_machine)
cls.isolated_network_offering = NetworkOffering.create(cls.api_client, cls.services["isolated_network_offering"], )
cls._cleanup.append(cls.isolated_network_offering)
cls.isolated_network_offering.update(cls.api_client, state='Enabled')
cls.isolated_network = Network.create(cls.api_client, cls.services["isolated_network"], cls.account.name,
cls.account.domainid, networkofferingid=cls.isolated_network_offering.id)
cls._cleanup.append(cls.isolated_network)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
def tearDown(self):
super(TestFailureScenariosAddNetworkToVM, self).tearDown()
@classmethod
def tearDownClass(cls):
try:
cls.isolated_network_offering.update(cls.api_client, state='Disabled')
except Exception as e:
cls.debug("Exception during disabling network offering : %s" % e)
super(TestFailureScenariosAddNetworkToVM, cls).tearDownClass()
@attr(tags=["advanced", "dvs"])
def test_15_add_nic_wrong_vm_id(self):
"""Add network to vm with wrong vm id"""
# 1. Call add network to VM API with correct network id but wrong vm id
# Validate the following:
# 1. API should throw exception saying unable to find virtual machine
cmd = addNicToVirtualMachine.addNicToVirtualMachineCmd()
cmd.virtualmachineid = random_gen(id="virtual_machine", size=30)
cmd.networkid = self.isolated_network.id
with self.assertRaises(Exception) as e:
self.apiclient.addNicToVirtualMachine(cmd)
self.debug("addNicToVirtualMachine API failed with exception: %s" % e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_16_add_nic_wrong_network_id(self):
"""Add network to vm with wrong network id"""
# 1. Call add network to VM API with correct network id but wrong network id
# Validate the following:
# 1. API should throw exception saying unable to find a network
cmd = addNicToVirtualMachine.addNicToVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id
cmd.networkid = random_gen(id="network_id", size=30)
with self.assertRaises(Exception) as e:
self.apiclient.addNicToVirtualMachine(cmd)
self.debug("addNicToVirtualMachine API failed with exception: %s" % e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_17_add_nic_different_zone(self):
"""Add network to vm where both belong to different zones"""
# 1. Deploy a VM in zone 1
# 2. Create a network in zone 2
# 3. Try to add this network to the VM (both belong to different zones)
# Validate the following:
# 1. API should throw exception vminstance is in zone<id>, but network is in zone <id>
foreignZoneId = None
zones = list_zones(self.apiclient, available=True)
list_zones_validation_result = validateList(zones)
self.assertEqual(list_zones_validation_result[0], PASS, "list zones validation failed due to: %s" %
list_zones_validation_result[2])
if len(zones) >= 2:
for zone in zones:
if zone.id != self.zone.id:
foreignZoneId = zone.id
break
else:
self.skipTest("This test requires at least two zones to be present in the setup")
self.services["isolated_network"]["zoneid"] = foreignZoneId
self.debug("Creating isolated network in zone %s which is foreign to VM" %
foreignZoneId)
isolated_network = Network.create(self.apiclient, self.services["isolated_network"],
self.account.name, self.account.domainid,
networkofferingid=self.isolated_network_offering.id)
self.cleanup.append(isolated_network)
self.debug("Created isolated network %s in zone %s" %
(isolated_network.id, foreignZoneId))
self.debug("Trying to add network to VM, both belonging to different zones")
cmd = addNicToVirtualMachine.addNicToVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id
cmd.networkid = isolated_network.id
with self.assertRaises(Exception) as e:
time.sleep(5)
self.apiclient.addNicToVirtualMachine(cmd)
self.debug("addNicToVirtualMachine API failed with exception: %s" % e.exception)
return
@attr(tags=["invalid"])
def test_18_add_nic_basic_zone(self):
"""Add network to vm in basic zone"""
# 1. Deploy a vm and create network in basic zone
# 2. Try adding network to vm
# Validate following
# 1. API should throw exception saying Can't add a new nic to vm in basic network
basicZone = None
zones = list_zones(self.apiclient, available=True)
list_zones_validation_result = validateList(zones)
self.assertEqual(list_zones_validation_result[0], PASS, "list zones validation failed due to: %s" %
list_zones_validation_result[2])
for zone in zones:
if zone.networktype.lower() == 'BASIC':
basicZone = zone.id
break
if basicZone is None:
self.skipTest("This test requires at least one basic zone to be present in the setup")
self.services["isolated_network"]["zoneid"] = basicZone.id
self.debug("Creating isolated network in basic zone: %s" % basicZone.id)
isolated_network = Network.create(self.apiclient, self.services["isolated_network"],
networkofferingid=self.isolated_network_offering.id)
self.cleanup.append(isolated_network)
self.debug("Created isolated network %s:" % isolated_network.id)
self.services["virtual_machine"]["zoneid"] = basicZone.id
self.debug("Deploying virtual machine in basic zone: %s" % basicZone.id)
virtual_machine = VirtualMachine.create(self.apiclient, self.services["virtual_machine"],
serviceofferingid=self.service_offering.id,
mode=basicZone.networktype)
self.cleanup.append(virtual_machine)
time.sleep(self.services["sleep"])
self.debug("Deployed virtual machine %s: " % virtual_machine.id)
cmd = addNicToVirtualMachine.addNicToVirtualMachineCmd()
cmd.virtualmachineid = virtual_machine.id
cmd.networkid = isolated_network.id
self.dedbug("Trying to add isolated network to VM (both in basic zone,\
this operation should fail")
with self.assertRaises(Exception) as e:
time.sleep(5)
self.apiclient.addNicToVirtualMachine(cmd)
return
@attr(tags=["advanced", "dvs"])
def test_26_add_nic_insufficient_permission(self):
"""Try to add network to vm with insufficient permission"""
# 1. Call add network to VM API with api client of other account
# Validate the following:
# 1. API should throw exception saying insufficient permission
cmd = addNicToVirtualMachine.addNicToVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id
cmd.networkid = self.isolated_network.id
self.debug("Creating new account")
account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id)
self.cleanup.append(account)
self.debug("Created account %s" % account.name)
self.debug("creating user api client for account: %s" % account.name)
api_client = self.testClient.getUserApiClient(UserName=account.name, DomainName=self.account.domain)
self.debug("Trying to add network to vm with this api client, this should fail due to \
insufficient permission")
with self.assertRaises(Exception) as e:
time.sleep(5)
api_client.addNicToVirtualMachine(cmd)
return
class TestFailureScenariosRemoveNicFromVM(cloudstackTestCase):
@classmethod
def setUpClass(cls):
cls.testClient = super(TestFailureScenariosRemoveNicFromVM, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
hypervisor = get_hypervisor_type(cls.api_client)
if hypervisor.lower() not in ["xenserver", "kvm"]:
raise unittest.SkipTest("This feature is supported only on XenServer and KVM")
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
# Set Zones and disk offerings
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = template.id
# Create Accounts & networks
cls.services["isolated_network"]["zoneid"] = cls.zone.id
cls.services["shared_network"]["zoneid"] = cls.zone.id
cls._cleanup = []
cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.virtual_machine = VirtualMachine.create(cls.api_client, cls.services["virtual_machine"],
accountid=cls.account.name, domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.zone.networktype)
cls._cleanup.append(cls.virtual_machine)
cls.isolated_network_offering = NetworkOffering.create(cls.api_client, cls.services["isolated_network_offering"], )
cls._cleanup.append(cls.isolated_network_offering)
cls.isolated_network_offering.update(cls.api_client, state='Enabled')
cls.isolated_network = Network.create(cls.api_client, cls.services["isolated_network"], cls.account.name,
cls.account.domainid, networkofferingid=cls.isolated_network_offering.id)
cls._cleanup.append(cls.isolated_network)
cls.virtual_machine.add_nic(cls.api_client, cls.isolated_network.id)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
def tearDown(self):
super(TestFailureScenariosRemoveNicFromVM, self).tearDown()
@classmethod
def tearDownClass(cls):
try:
cls.isolated_network_offering.update(cls.api_client, state='Disabled')
except Exception as e:
cls.debug("Exception during disabling of network offering : %s" % e)
super(TestFailureScenariosRemoveNicFromVM, cls).tearDownClass()
@attr(tags=["advanced", "dvs"])
def test_19_remove_nic_wrong_vm_id(self):
"""Try to remove nic from a vm providing wrong vm id to API"""
# (Frist two steps are perfromed in setupClass)
# 1. Deploy Vm in account
# 2. Add network to VM
# 3. Remove the nic added by the newly added network providing wrong vm id to the API
# Validate the following:
# 1. API throws exception unable to find a virtual machine with id
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
vm = vm_list_validation_result[1]
nics = [x for x in vm.nic if x.networkid == self.isolated_network.id]
self.assertEqual(len(nics), 1, "There should be exactly one nic corresponding to the isolate\
network %s" % self.isolated_network.id)
cmd = removeNicFromVirtualMachine.removeNicFromVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id + random_gen()
cmd.nicid = nics[0].id
with self.assertRaises(Exception) as e:
self.apiclient.removeNicFromVirtualMachine(cmd)
self.debug("removeNicFromVirtualMachine API failed with exception: %s" % e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_20_remove_nic_wrong_nic_id(self):
"""Try to remove nic from a vm providing wrong nic id to API"""
# (Frist two steps are perfromed in setupClass)
# 1. Deploy Vm in account
# 2. Add network to VM
# 3. Remove the nic added by the newly added network providing wrong nic id to the API
# Validate the following:
# 1. API throws exception unable to find nic with id
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
vm = vm_list_validation_result[1]
nics = [x for x in vm.nic if x.networkid == self.isolated_network.id]
self.assertEqual(len(nics), 1, "There should be exactly one nic corresponding to the isolate\
network %s" % self.isolated_network.id)
cmd = removeNicFromVirtualMachine.removeNicFromVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id
cmd.nicid = nics[0].id + random_gen()
with self.assertRaises(Exception) as e:
self.apiclient.removeNicFromVirtualMachine(cmd)
self.debug("removeNicFromVirtualMachine API failed with exception: %s" % e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_27_remove_nic_insufficient_permission(self):
"""Try to remove nic from vm with insufficient permission"""
# 1. Call remove network from VM API with api client of other account
# Validate the following:
# 1. API should throw exception saying insufficient permission
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
vm = vm_list_validation_result[1]
nics = [x for x in vm.nic if x.networkid == self.isolated_network.id]
self.assertEqual(len(nics), 1, "There should be exactly one nic corresponding to the isolate\
network %s" % self.isolated_network.id)
cmd = removeNicFromVirtualMachine.removeNicFromVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id
cmd.nicid = nics[0].id
self.debug("Creating new account")
account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id)
self.cleanup.append(account)
self.debug("Created account %s" % account.name)
self.debug("creating user api client for account: %s" % account.name)
api_client = self.testClient.getUserApiClient(UserName=account.name, DomainName=self.account.domain)
self.debug("Trying to add network to vm with this api client, this should fail due to \
insufficient permission")
with self.assertRaises(Exception) as e:
api_client.removeNicFromVirtualMachine(cmd)
self.debug("removeNicFromVirtualMachine API failed with exception: %s" % e.exception)
self.apiclient.removeNicFromVirtualMachine(cmd)
return
class TestFailureScenariosUpdateVirtualMachineNIC(cloudstackTestCase):
@classmethod
def setUpClass(cls):
cls.testClient = super(TestFailureScenariosUpdateVirtualMachineNIC, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
hypervisor = get_hypervisor_type(cls.api_client)
if hypervisor.lower() not in ["xenserver", "kvm"]:
raise unittest.SkipTest("This feature is supported only on XenServer and KVM")
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
# Set Zones and disk offerings
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = template.id
# Create Accounts & networks
cls.services["isolated_network"]["zoneid"] = cls.zone.id
cls.services["shared_network"]["zoneid"] = cls.zone.id
cls._cleanup = []
cls.addednics = []
cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.virtual_machine = VirtualMachine.create(cls.api_client, cls.services["virtual_machine"],
accountid=cls.account.name, domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id, mode=cls.zone.networktype)
cls._cleanup.append(cls.virtual_machine)
cls.defaultNetworkId = cls.virtual_machine.nic[0].networkid
# Create Shared Network Offering
cls.isolated_network_offering = NetworkOffering.create(cls.api_client, cls.services["isolated_network_offering"], )
cls._cleanup.append(cls.isolated_network_offering)
# Enable Isolated Network offering
cls.isolated_network_offering.update(cls.api_client, state='Enabled')
cls.isolated_network = Network.create(cls.api_client, cls.services["isolated_network"],
cls.account.name, cls.account.domainid,
networkofferingid=cls.isolated_network_offering.id)
cls._cleanup.append(cls.isolated_network)
vm_with_nic = cls.virtual_machine.add_nic(cls.api_client, cls.isolated_network.id)
nics = [x for x in vm_with_nic.nic if x.networkid == cls.isolated_network.id]
cls.addednics.append(nics[-1])
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
def tearDown(self):
super(TestFailureScenariosUpdateVirtualMachineNIC, self).tearDown()
@classmethod
def tearDownClass(cls):
try:
for nic in cls.addednics:
cls.virtual_machine.remove_nic(cls.apiclient, nic.id)
except Exception as e:
cls.debug("Exception during removal of nics : %s" % e)
try:
cls.isolated_network_offering.update(cls.api_client, state='Disabled')
except Exception as e:
cls.debug("Exception during disabling of network offering : %s" % e)
super(TestFailureScenariosUpdateVirtualMachineNIC, cls).tearDownClass()
@attr(tags=["advanced", "dvs"])
def test_21_update_nic_wrong_vm_id(self):
"""update default nic of vm providing wrong vm id to the API"""
# (First two steps are performed in setupClass)
# 1. Deploy Vm in account
# 2. Add network to VM
# 3. Update default nic of VM (Make the newly added NIC as default) by providing wrong
# vm id to the API
# Validate the following:
# 1. API throws exception saying can't find the virtual machine
self.debug("Listing virtual machine so that to retrive the list of non-default and default nic")
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
if len(vm_list[0].nic) != 2:
self.fail("VM should have exactly two NICs")
defaultNicIdBeforeUpdate = None
nonDefaultNicIdBeforeUpdate = None
for nic in vm_list[0].nic:
if nic.isdefault:
defaultNicIdBeforeUpdate = nic.id
else:
nonDefaultNicIdBeforeUpdate = nic.id
self.debug("Default nic of VM is %s and non default nic of VM is %s"
% (defaultNicIdBeforeUpdate, nonDefaultNicIdBeforeUpdate))
self.debug("Making non default nic as default nic")
cmd = updateDefaultNicForVirtualMachine.updateDefaultNicForVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id + random_gen()
cmd.nicid = nonDefaultNicIdBeforeUpdate
with self.assertRaises(Exception) as e:
self.apiclient.updateDefaultNicForVirtualMachine(cmd)
self.debug("updateDefaultNicForVirtualMachine API failed with exception: %s" %
e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_22_update_nic_wrong_nic_id(self):
"""update default nic of vm providing wrong nic id to the API"""
# (First two steps are performed in setupClass)
# 1. Deploy Vm in account
# 2. Add network to VM
# 3. Update default nic of VM (Make the newly added NIC as default) by providing wrong
# nic id to the API
# Validate the following:
# 1. API throws exception saying can't find the nic with id
self.debug("Listing virtual machine so that to retrive the list of non-default and default nic")
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
if len(vm_list[0].nic) != 2:
self.fail("VM should have exactly two NICs")
defaultNicIdBeforeUpdate = None
nonDefaultNicIdBeforeUpdate = None
for nic in vm_list[0].nic:
if nic.isdefault:
defaultNicIdBeforeUpdate = nic.id
else:
nonDefaultNicIdBeforeUpdate = nic.id
self.debug("Default nic of VM is %s and non default nic of VM is %s"
% (defaultNicIdBeforeUpdate, nonDefaultNicIdBeforeUpdate))
self.debug("Making non default nic as default nic")
cmd = updateDefaultNicForVirtualMachine.updateDefaultNicForVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id
cmd.nicid = nonDefaultNicIdBeforeUpdate + random_gen()
with self.assertRaises(Exception) as e:
self.apiclient.updateDefaultNicForVirtualMachine(cmd)
self.debug("updateDefaultNicForVirtualMachine API failed with exception: %s" %
e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_23_update_nic_incorrect_vm_state(self):
"""update default nic of vm when vm is state is not Running or Stopped"""
# (First two steps are performed in setupClass)
# 1. Deploy Vm in account
# 2. Add network to VM
# 3. Destroy virtual machine so that the VM state becomes Destroyed or Expunging
# 4. Update default nic of VM (Make the newly added NIC as default)
# Validate the following:
# 1. API throws exception instance is not Running or Stopped
self.debug("Creating new account")
account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id)
self.cleanup.append(account)
self.debug("Creating virtual machine in the account %s" % account.name)
virtual_machine = VirtualMachine.create(self.api_client, self.services["virtual_machine"],
accountid=account.name, domainid=account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype)
time.sleep(self.services["sleep"])
self.debug("Created virtual machine %s" % virtual_machine.id)
self.debug("Creating isolated network in account %s" % account.name)
isolated_network = Network.create(self.apiclient, self.services["isolated_network"], account.name,
account.domainid, networkofferingid=self.isolated_network_offering.id)
self.debug("Created isolated network %s" % isolated_network.id)
self.debug("Adding isolated network %s to vm %s" % (isolated_network.id, virtual_machine.id))
virtual_machine.add_nic(self.apiclient, isolated_network.id)
self.debug("Listing virtual machine so that to retrive the list of non-default and default nic")
vm_list = list_virtual_machines(self.apiclient, id=virtual_machine.id, listall=True)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
if len(vm_list[0].nic) != 2:
self.fail("VM should have exactly two NICs")
defaultNicIdBeforeUpdate = None
nonDefaultNicIdBeforeUpdate = None
for nic in vm_list[0].nic:
if nic.isdefault:
defaultNicIdBeforeUpdate = nic.id
else:
nonDefaultNicIdBeforeUpdate = nic.id
self.debug("Default nic of VM is %s and non default nic of VM is %s"
% (defaultNicIdBeforeUpdate, nonDefaultNicIdBeforeUpdate))
self.debug("Destroying VM %s" % virtual_machine.id)
virtual_machine.delete(self.apiclient, expunge=False)
self.debug("Making non default nic as default nic")
cmd = updateDefaultNicForVirtualMachine.updateDefaultNicForVirtualMachineCmd()
cmd.virtualmachineid = virtual_machine.id
cmd.nicid = nonDefaultNicIdBeforeUpdate
with self.assertRaises(Exception) as e:
self.apiclient.updateDefaultNicForVirtualMachine(cmd)
self.debug("updateDefaultNicForVirtualMachine API failed with exception: %s" %
e.exception)
return
@attr(tags=["advanced", "dvs"])
def test_28_update_nic_insufficient_permission(self):
"""Try to update default nic of vm with insufficient permission"""
# 1. Call update nic of VM API with api client of other account
# Validate the following:
# 1. API should throw exception saying insufficient permission
account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id)
self.cleanup.append(account)
self.debug("Created account %s" % account.name)
self.debug("creating user api client for account: %s" % account.name)
api_client = self.testClient.getUserApiClient(UserName=account.name, DomainName=self.account.domain)
self.debug("Listing virtual machine so that to retrive the list of non-default and default nic")
vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
vm_list_validation_result = validateList(vm_list)
self.assertEqual(vm_list_validation_result[0], PASS, "vm list validation failed due to %s" %
vm_list_validation_result[2])
if len(vm_list[0].nic) != 2:
self.fail("VM should have exactly two NICs")
defaultNicIdBeforeUpdate = None
nonDefaultNicIdBeforeUpdate = None
for nic in vm_list[0].nic:
if nic.isdefault:
defaultNicIdBeforeUpdate = nic.id
else:
nonDefaultNicIdBeforeUpdate = nic.id
self.debug("Default nic of VM is %s and non default nic of VM is %s"
% (defaultNicIdBeforeUpdate, nonDefaultNicIdBeforeUpdate))
self.debug("Making non default nic as default nic")
cmd = updateDefaultNicForVirtualMachine.updateDefaultNicForVirtualMachineCmd()
cmd.virtualmachineid = self.virtual_machine.id
cmd.nicid = nonDefaultNicIdBeforeUpdate
with self.assertRaises(Exception) as e:
api_client.updateDefaultNicForVirtualMachine(cmd)
return
Reference in New Issue View Git Blame Copy Permalink