def test_exclude_list_with_new_attach_port(self):
port_client = self.manager.ports_client
self.green = self.setup_vm_enviornment(self.manager, 'green', True)
vm_id = self.green['serv1']['id']
net_id = self.green['network']['id']
name = 'disabled-port-security-port'
kwargs = {
'name': name,
'network_id': net_id,
'port_security_enabled': 'false'
}
# Create Port
port = HELO.create_port(self, client=port_client, **kwargs)
port_id = port['id']
kwargs = {'port_id': port_id}
# Attach interface to vm
self.interface_client.create_interface(vm_id, **kwargs)
# Fetch exclude list information from beckend
items = self.vsm.get_excluded_vm_name_list()
exclude_list = [item.encode('utf-8') for item in items]
for exclude_vm in exclude_list:
if vm_id in exclude_vm:
LOG.info(_LI("Vm in exclude list"))
# Update Port security to disabled
port_client.update_port(port_id=port_id, port_security_enabled='true')
items = self.vsm.get_excluded_vm_name_list()
exclude_list = [item.encode('utf-8') for item in items]
if exclude_vm in exclude_list:
if vm_id not in exclude_vm:
LOG.info(_LI("Vm not in exclude list"))
# Detach interface from vm
self.interface_client.delete_interface(vm_id, port_id)
def create_l2gw(self, l2gw_name, l2gw_param):
"""
Creates L2GW and return the response.
:param l2gw_name: name of the L2GW
:param l2gw_param: L2GW parameters
:return: response of L2GW create API
"""
LOG.info(
_LI("l2gw name: %(name)s, l2gw_param: %(devices)s ") % {
"name": l2gw_name,
"devices": l2gw_param
})
devices = []
for device_dict in l2gw_param:
interface = [{
"name": device_dict["iname"],
"segmentation_id": device_dict["vlans"]
}] if "vlans" in device_dict else [{
"name": device_dict["iname"]
}]
device = {
"device_name": device_dict["dname"],
"interfaces": interface
}
devices.append(device)
l2gw_request_body = {"devices": devices}
LOG.info(_LI(" l2gw_request_body: %s") % l2gw_request_body)
rsp = self.l2gw_client.create_l2_gateway(name=l2gw_name,
**l2gw_request_body)
LOG.info(_LI(" l2gw response: %s") % rsp)
self.l2gw_created[rsp[constants.L2GW]["id"]] = rsp[constants.L2GW]
return rsp, devices
def create_l2gw(self, l2gw_name, l2gw_param):
"""
Creates L2GW and return the response.
:param l2gw_name: name of the L2GW
:param l2gw_param: L2GW parameters
:return: response of L2GW create API
"""
LOG.info(_LI("l2gw name: %(name)s, l2gw_param: %(devices)s ") %
{"name": l2gw_name, "devices": l2gw_param})
devices = []
for device_dict in l2gw_param:
interface = [{"name": device_dict["iname"],
"segmentation_id": device_dict[
"vlans"]}] if "vlans" in device_dict else [
{"name": device_dict["iname"]}]
device = {"device_name": device_dict["dname"],
"interfaces": interface}
devices.append(device)
l2gw_request_body = {"devices": devices}
LOG.info(_LI(" l2gw_request_body: %s") % l2gw_request_body)
rsp = self.l2gw_client.create_l2_gateway(
name=l2gw_name, **l2gw_request_body)
LOG.info(_LI(" l2gw response: %s") % rsp)
self.l2gw_created[rsp[constants.L2GW]["id"]] = rsp[constants.L2GW]
return rsp, devices
def test_disabled_network_port_security(self):
network_client = self.manager.networks_client
port_client = self.manager.ports_client
net_id, network, subnet =\
self.create_project_network_subnet('admin')
kwargs = {'port_security_enabled': 'false'}
# Update network to disbale port security
network_client.update_network(network_id=net_id, **kwargs)
name = 'disabled-port-security-port'
kwargs = {'name': name, 'network_id': net_id}
# Create port under network
port = HELO.create_port(self, client=port_client, **kwargs)
port_id = port['id']
# Check port security of created port
port_details = port_client.show_port(port_id=port_id)
if (port_details['port']['port_security_enabled'] == 'false'):
LOG.info(_LI("Port security of port is disabled"))
kwargs = {'port_security_enabled': 'true'}
# Update port security of network to enabled
network_client.update_network(network_id=net_id, **kwargs)
name = 'disabled-port-security-port'
kwargs = {'name': name, 'network_id': net_id}
port = HELO.create_port(self, client=port_client, **kwargs)
port_id = port['id']
port_details = port_client.show_port(port_id=port_id)
if (port_details['port']['port_security_enabled'] == 'true'):
LOG.info(_LI("Port security of port is enabled"))
def test_l2_gateway_connection_list(self):
"""
Create l2 gateway connection using one vlan and test l2 gateway
connection list api.
"""
LOG.info(_LI("Testing test_l2_gateway_connection_create api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
# Create 2 l2 gateways.
l2gw_rsp, _ = self.create_l2gw(l2gw_name, l2gw_param)
# Create 2 l2 gateway connections.
l2gwc_param = {
"l2_gateway_id": l2gw_rsp[constants.L2GW]["id"],
"network_id": self.network["id"],
"segmentation_id": self.VLAN_1
}
l2gwc_rsp = self.create_l2gw_connection(l2gwc_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, l2gwc_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
list_rsp = self.l2gwc_client.list_l2_gateway_connections()
LOG.info(_LI("l2gw connection list response: %s") % list_rsp)
# Assert in case of failure.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_200, list_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_200})
self.assertEqual(l2gwc_rsp["l2_gateway_connection"]["id"],
list_rsp["l2_gateway_connections"][0]["id"],
"l2gw connection list does not show proper id")
self.assertEqual(
l2gwc_rsp["l2_gateway_connection"]["l2_gateway_id"],
list_rsp["l2_gateway_connections"][0]["l2_gateway_id"],
"l2gw connection list does not show proper "
"l2_gateway_id")
self.assertEqual(
l2gwc_rsp["l2_gateway_connection"]["network_id"],
list_rsp["l2_gateway_connections"][0]["network_id"],
"l2gw connection list does not show proper "
"network_id")
self.assertEqual(
l2gwc_rsp["l2_gateway_connection"]["tenant_id"],
list_rsp["l2_gateway_connections"][0]["tenant_id"],
"l2gw connection list does not show proper tenant_id")
self.assertEqual(
l2gwc_rsp["l2_gateway_connection"]["segmentation_id"],
str(list_rsp["l2_gateway_connections"][0]["segmentation_id"]),
"l2gw connection list does not show proper "
"segmentation_id")
self.addCleanup(self.l2gw_cleanup)
def delete_l2gw(self, l2gw_id):
"""
Delete L2gw.
:param l2gw_id: L2GW id to delete l2gw.
:return: response of the l2gw delete API.
"""
LOG.info(_LI("L2GW id: %(id)s to be deleted.") % {"id": l2gw_id})
rsp = self.l2gw_client.delete_l2_gateway(l2gw_id)
LOG.info(_LI("response : %(rsp)s") % {"rsp": rsp})
return rsp
def delete_l2gw(self, l2gw_id):
"""
Delete L2gw.
:param l2gw_id: L2GW id to delete l2gw.
:return: response of the l2gw delete API.
"""
LOG.info(_LI("L2GW id: %(id)s to be deleted.") % {"id": l2gw_id})
rsp = self.l2gw_client.delete_l2_gateway(l2gw_id)
LOG.info(_LI("response : %(rsp)s") % {"rsp": rsp})
return rsp
def delete_l2gw_connection(self, l2gwc_id):
"""
Delete L2GWC and returns the response.
:param l2gwc_id: L2GWC id to delete L2GWC.
:return: response of the l2gwc delete API.
"""
LOG.info(
_LI("L2GW connection id: %(id)s to be deleted") % {"id": l2gwc_id})
rsp = self.l2gwc_client.delete_l2_gateway_connection(l2gwc_id)
LOG.info(_LI("response : %(rsp)s") % {"rsp": rsp})
return rsp
def delete_l2gw_connection(self, l2gwc_id):
"""
Delete L2GWC and returns the response.
:param l2gwc_id: L2GWC id to delete L2GWC.
:return: response of the l2gwc delete API.
"""
LOG.info(_LI("L2GW connection id: %(id)s to be deleted")
% {"id": l2gwc_id})
rsp = self.l2gwc_client.delete_l2_gateway_connection(l2gwc_id)
LOG.info(_LI("response : %(rsp)s") % {"rsp": rsp})
return rsp
def test_exclude_list_with_multiple_ports(self):
port_client = self.manager.ports_client
self.green = self.setup_vm_enviornment(self.manager, 'green', True)
vm_id = self.green['serv1']['id']
net_id = self.green['network']['id']
name = 'disabled-port-security-port1'
kwargs = {
'name': name,
'network_id': net_id,
'port_security_enabled': 'false'
}
port1 = HELO.create_port(self, client=port_client, **kwargs)
port2 = HELO.create_port(self, client=port_client, **kwargs)
port1_id = port1['id']
kwargs = {'port_id': port1_id}
self.interface_client.create_interface(vm_id, **kwargs)
items = self.vsm.get_excluded_vm_name_list()
exclude_list = [item.encode('utf-8') for item in items]
for exclude_vm in exclude_list:
if vm_id in exclude_vm:
LOG.info(_LI("Vm in exclude list"))
name = 'disabled-port-security-port2'
kwargs = {
'name': name,
'network_id': net_id,
'port_security_enabled': 'false'
}
port2_id = port2['id']
kwargs = {'port_id': port2_id}
self.interface_client.create_interface(vm_id, **kwargs)
items = self.vsm.get_excluded_vm_name_list()
exclude_list = [item.encode('utf-8') for item in items]
for exclude_vm in exclude_list:
if vm_id in exclude_vm:
LOG.info(_LI("Vm in exclude list"))
port_client.update_port(port_id=port2_id, port_security_enabled='true')
items = self.vsm.get_excluded_vm_name_list()
exclude_list = [item.encode('utf-8') for item in items]
for exclude_vm in exclude_list:
if vm_id in exclude_vm:
LOG.info(_LI("Vm in exclude list"))
port_client.update_port(port_id=port1_id, port_security_enabled='true')
items = self.vsm.get_excluded_vm_name_list()
exclude_list = [item.encode('utf-8') for item in items]
if exclude_vm in exclude_list:
if vm_id not in exclude_vm:
LOG.info(_LI("Vm not in exclude list"))
self.interface_client.delete_interface(vm_id, port1_id)
self.interface_client.delete_interface(vm_id, port2_id)
def test_delete_tap_flow(self):
"""
Tap flow delete api is tested , Tap Service is created with
destination port associated with floating ip
"""
LOG.info(
_LI("Testing Tap flow delete api with floating ip associated to "
"destination port "))
# Create tap service env
fip, device_tap_service = self._create_tap_service_env(port_index=0)
# Create Tap Service
rsp_tap_service = self.tclient.create_tap_service(**device_tap_service)
LOG.info(
_LI("response from tap service : %(rsp)s") %
{"rsp": rsp_tap_service})
self.assertEqual('201', rsp_tap_service.response["status"],
"Response code is not 201 ")
# Create Tap Flow env
device_tap_flow = self._create_tap_flow_env(
tap_service_id=rsp_tap_service['tap_service']['id'],
tap_flow_direction='BOTH',
src_port_index=1)
# Create Tap flow
rsp_tap_flow = self.tclient.create_tap_flow(**device_tap_flow)
LOG.info(_LI("response from flow : %(rsp)s") % {"rsp": rsp_tap_flow})
self.assertEqual('201', rsp_tap_flow.response["status"],
"Response code is not 201 ")
self.assertIn(self.ports[1]['id'],
rsp_tap_flow['tap_flow']['source_port'])
self.assertEqual(device_tap_flow['name'],
rsp_tap_flow['tap_flow']['name'])
self.assertEqual(device_tap_flow['direction'],
rsp_tap_flow['tap_flow']['direction'])
self.assertEqual(rsp_tap_service['tap_service']['id'],
rsp_tap_flow['tap_flow']['tap_service_id'])
rsp_tap_flow_delete = self.tclient.delete_tap_flow(
rsp_tap_flow['tap_flow']['id'])
LOG.info(
_LI("response from tap list : %(rsp)s") %
{"rsp": rsp_tap_flow_delete})
self.assertEqual('204', rsp_tap_flow_delete.response["status"],
"Response code is not 204 ")
rsp_tap_list_flow = self.tclient.list_tap_flow()
LOG.info(
_LI("response from tap list : %(rsp)s") %
{"rsp": rsp_tap_list_flow})
self._resource_cleanup(fip, rsp_tap_service['tap_service']['id'],
'null')
def test_create_tap_flow(self):
"""
Tap flow create api is tested , Tap Service is created with
destination port associated with floating ip
"""
LOG.info(
_LI("Testing Tap flow create api with direction BOTH and "
"floating ip associated to destination port "))
# Create tap service env
fip, device_tap_service = self._create_tap_service_env(port_index=0)
# Create Tap Service
rsp_tap_service = self.tclient.create_tap_service(**device_tap_service)
LOG.info(
_LI("response from tap service : %(rsp)s") %
{"rsp": rsp_tap_service})
self.assertEqual('201', rsp_tap_service.response["status"],
"Response code is not 201 ")
# Create Tap Flow env
device_tap_flow = self._create_tap_flow_env(
tap_service_id=rsp_tap_service['tap_service']['id'],
tap_flow_direction='BOTH',
src_port_index=1)
# Create Tap flow
rsp_tap_flow = self.tclient.create_tap_flow(**device_tap_flow)
LOG.info(_LI("response from flow : %(rsp)s") % {"rsp": rsp_tap_flow})
# NSX backend check for Switch Profile
nsx_switch_profiles = self.nsx.get_logical_switch_profiles()
switch_profile = []
for ls in nsx_switch_profiles:
if ls['display_name'] == device_tap_flow['name']:
self.assertIn(ls['direction'], 'BIDIRECTIONAL')
self.assertIn(ls['destinations'][0],
fip['floating_ip_address'])
switch_profile = [ls]
self.assertNotEqual(len(switch_profile), 0, "Port mirror profile is "
"not found in NSX ")
self.assertEqual('201', rsp_tap_flow.response["status"],
"Response code is not 201 ")
self.assertIn(self.ports[1]['id'],
rsp_tap_flow['tap_flow']['source_port'])
self.assertEqual(device_tap_flow['name'],
rsp_tap_flow['tap_flow']['name'])
self.assertEqual(device_tap_flow['direction'],
rsp_tap_flow['tap_flow']['direction'])
self.assertEqual(rsp_tap_service['tap_service']['id'],
rsp_tap_flow['tap_flow']['tap_service_id'])
self._resource_cleanup(fip, rsp_tap_service['tap_service']['id'],
rsp_tap_flow['tap_flow']['id'])
def test_l2_gateway_with_multiple_vlans(self):
"""
Create l2gw based on UUID and bridge cluster name. It creates l2gw.
To create l2gw we need bridge cluster name (interface name) and
bridge cluster UUID (device name) from NSX manager and vlan id.
"""
LOG.info(_LI("Testing l2_gateway_create api with segmentation ID"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name,
"vlans": [self.VLAN_1, self.VLAN_2]}
l2gw_param = [device_1]
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
rsp.response["status"],
"Response code is not %(code)s" % {
"code": constants.EXPECTED_HTTP_RESPONSE_201})
self.assertEqual(requested_devices[0]["device_name"],
rsp[constants.L2GW]["devices"][0]["device_name"],
"Device name is not the same as expected")
self.assertEqual(requested_devices[0]["interfaces"][0][
"name"],
rsp[constants.L2GW]["devices"][0]["interfaces"][0][
"name"],
"Interface name is not the same as expected")
requested_vlans = \
requested_devices[0]["interfaces"][0]["segmentation_id"]
response_vlans = rsp[constants.L2GW]["devices"][0]["interfaces"][0][
"segmentation_id"]
for id in requested_vlans:
self.assertIn(id, response_vlans)
self.resource_cleanup()
def test_l2_gateway_list(self):
"""
list created l2gw.
"""
LOG.info(_LI("Testing l2_gateway_list api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name,
"vlans": [self.VLAN_1]}
l2gw_param = [device_1]
l2gw_rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
l2gw_rsp.response["status"],
"Response code is not %(code)s" % {
"code": constants.EXPECTED_HTTP_RESPONSE_201})
list_rsp = self.l2gw_client.list_l2_gateways()
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_200,
list_rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_200})
for l2gw in list_rsp[constants.L2GWS]:
if l2gw["id"] == l2gw_rsp[constants.L2GW]["id"]:
list_rsp = l2gw
l2gw_rsp = l2gw_rsp[constants.L2GW]
break
self.assertEqual(l2gw_rsp, list_rsp, "L2GW create response and L2GW "
"list response does not match.")
self.resource_cleanup()
def test_l2_gateway_delete(self):
"""
Delete l2gw will create l2gw and delete recently created l2gw. To
delete l2gw we need l2gw id.
"""
LOG.info(_LI("Testing l2_gateway_delete api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
# Create l2gw to delete it.
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
l2gw_id = rsp[constants.L2GW]["id"]
# Delete l2gw.
rsp = self.delete_l2gw(l2gw_id)
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_204, rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_204})
self.l2gw_created.pop(l2gw_id)
self.resource_cleanup()
def test_l2_gateway_update_interface(self):
"""
Update l2gw will update info in already created l2gw. To
update l2gw we need l2gw id and payload to update.
"""
LOG.info(_LI("Testing l2_gateway_update api"))
device_name, interface_name = self.nsx_bridge_cluster_info()
l2gw_name = data_utils.rand_name(constants.L2GW)
devices = {"devices": [{"device_name": device_name,
"interfaces": [{"name": interface_name}]}]
}
# Creating l2gw.
self.operate_l2gw(name=l2gw_name, devices=devices, task="create")
# Updating Interfaces.
devices = {"devices": [
{"device_name": device_name,
"interfaces": [{"name": "new_name",
"segmentation_id": [
self.VLAN_1]}],
"deleted_interfaces": [
{"name": interface_name}]}
]
}
# Updating already created l2gw with new interface.
self.operate_l2gw(name=l2gw_name, devices=devices, task="update")
self.resource_cleanup()
def test_l2_gateway_connection_delete(self):
"""
Delete l2gw will create l2gw and delete recently created l2gw. To
delete l2gw we need l2gw id.
"""
LOG.info(_LI("Testing l2_gateway_connection_delete api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
l2gw_rsp, _ = self.create_l2gw(l2gw_name, l2gw_param)
l2gwc_param = {
"l2_gateway_id": l2gw_rsp[constants.L2GW]["id"],
"network_id": self.network["id"],
"segmentation_id": self.VLAN_1
}
l2gwc_rsp = self.create_l2gw_connection(l2gwc_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, l2gwc_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
l2gwc_id = l2gwc_rsp[constants.L2GWC]["id"]
# Delete l2gw.
rsp = self.delete_l2gw_connection(l2gwc_id)
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_204, rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_204})
# Since we delete l2gwc pop that id from list.
self.l2gwc_created.pop(l2gwc_id)
self.addCleanup(self.l2gw_cleanup)
def update_l2_gateway(self, l2_gateway_id, **kwargs):
uri = constants.L2_GWS_BASE_URI + "/" + l2_gateway_id
post_data = {constants.L2GW: kwargs}
constants.LOG.info(
_LI("URI : %(uri)s, posting data : %(post_data)s") % {
"uri": uri, "post_data": post_data})
return self.update_resource(uri, post_data)
def test_l2_gateway_delete(self):
"""
Delete l2gw will create l2gw and delete recently created l2gw. To
delete l2gw we need l2gw id.
"""
LOG.info(_LI("Testing l2_gateway_delete api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
# Create l2gw to delete it.
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_201})
l2gw_id = rsp[constants.L2GW]["id"]
# Delete l2gw.
rsp = self.delete_l2gw(l2gw_id)
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_204,
rsp.response["status"],
"Response code is not %(code)s" % {
"code": constants.EXPECTED_HTTP_RESPONSE_204})
self.l2gw_created.pop(l2gw_id)
self.resource_cleanup()
def test_recreate_l2_gateway_connection(self):
"""
Recreate l2 gateway connection using same parameters.
"""
LOG.info(_LI("Testing test_l2_gateway_connection_create api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {
"dname": device_name,
"iname": interface_name,
"vlans": [self.VLAN_1]
}
l2gw_param = [device_1]
l2gw_rsp, _ = self.create_l2gw(l2gw_name, l2gw_param)
l2gwc_param = {
"l2_gateway_id": l2gw_rsp[constants.L2GW]["id"],
"network_id": self.network["id"]
}
l2gwc_rsp = self.create_l2gw_connection(l2gwc_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, l2gwc_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
self.assertRaises(lib_exc.Conflict, self.create_l2gw_connection,
l2gwc_param)
self.addCleanup(self.l2gw_cleanup)
def test_l2_gateway_list(self):
"""
list created l2gw.
"""
LOG.info(_LI("Testing l2_gateway_list api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {
"dname": device_name,
"iname": interface_name,
"vlans": [self.VLAN_1]
}
l2gw_param = [device_1]
l2gw_rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, l2gw_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
list_rsp = self.l2gw_client.list_l2_gateways()
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_200, list_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_200})
for l2gw in list_rsp[constants.L2GWS]:
if l2gw["id"] == l2gw_rsp[constants.L2GW]["id"]:
list_rsp = l2gw
l2gw_rsp = l2gw_rsp[constants.L2GW]
break
self.assertEqual(
l2gw_rsp, list_rsp, "L2GW create response and L2GW "
"list response does not match.")
self.resource_cleanup()
def test_active_l2_gateway_delete(self):
"""
Delete l2 gateway with active mapping.
"""
LOG.info(_LI("Testing test_l2_gateway_create api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
l2gw_rsp, _ = self.create_l2gw(l2gw_name, l2gw_param)
l2gwc_param = {
"l2_gateway_id": l2gw_rsp[constants.L2GW]["id"],
"network_id": self.network["id"],
"segmentation_id": self.VLAN_1
}
l2gwc_rsp = self.create_l2gw_connection(l2gwc_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, l2gwc_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
l2gw_id = l2gw_rsp[constants.L2GW]["id"]
# Delete l2gw must raise Conflict exception.
self.assertRaises(lib_exc.Conflict, self.delete_l2gw, l2gw_id)
self.addCleanup(self.l2gw_cleanup)
def test_l2_gateway_with_multiple_vlans(self):
"""
Create l2gw based on UUID and bridge cluster name. It creates l2gw.
To create l2gw we need bridge cluster name (interface name) and
bridge cluster UUID (device name) from NSX manager and vlan id.
"""
LOG.info(_LI("Testing l2_gateway_create api with segmentation ID"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name,
"vlans": [self.VLAN_1, self.VLAN_2]}
l2gw_param = [device_1]
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
rsp.response["status"],
"Response code is not %(code)s" % {
"code": constants.EXPECTED_HTTP_RESPONSE_201})
self.assertEqual(requested_devices[0]["device_name"],
rsp[constants.L2GW]["devices"][0]["device_name"],
"Device name is not the same as expected")
self.assertEqual(requested_devices[0]["interfaces"][0][
"name"],
rsp[constants.L2GW]["devices"][0]["interfaces"][0][
"name"],
"Interface name is not the same as expected")
requested_vlans = \
requested_devices[0]["interfaces"][0]["segmentation_id"]
response_vlans = rsp[constants.L2GW]["devices"][0]["interfaces"][0][
"segmentation_id"]
for id in requested_vlans:
self.assertIn(id, response_vlans)
self.resource_cleanup()
def test_l2_gateway_update_interface(self):
"""
Update l2gw will update info in already created l2gw. To
update l2gw we need l2gw id and payload to update.
"""
LOG.info(_LI("Testing l2_gateway_update api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
# Create l2gw to update l2gw name.
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
devices = {
"devices": [{
"device_name":
device_name,
"interfaces": [{
"name": "new_name",
"segmentation_id": [self.VLAN_1]
}],
"deleted_interfaces": [{
"name": interface_name
}]
}]
}
l2gw_id = rsp[constants.L2GW]["id"]
update_rsp = self.update_l2gw(l2gw_id, l2gw_name, devices)
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_200,
update_rsp.response["status"], "Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_200})
rsp_l2gw = update_rsp[constants.L2GW]
self.l2gw_created[rsp_l2gw["id"]] = rsp_l2gw
LOG.info(_LI("response : %(rsp_l2gw)s") % {"rsp_l2gw": rsp_l2gw})
if "segmentation_id" in devices["devices"][0]["interfaces"][0]:
self.assertEqual(
devices["devices"][0]["interfaces"][0]["segmentation_id"][0],
rsp_l2gw["devices"][0]["interfaces"][0]["segmentation_id"][0],
"L2GW segmentation id update failed!!!")
self.resource_cleanup()
def test_l2_gateway_update_l2gw_name(self):
"""
Update l2gw will update info in already created l2gw. To
update l2gw we need l2gw id and payload to update.
"""
LOG.info(_LI("Testing l2_gateway_update api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
# Create l2gw to update l2gw name.
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
devices = {
"devices": [{
"device_name": device_name,
"interfaces": [{
"name": interface_name
}]
}]
}
l2gw_id = rsp[constants.L2GW]["id"]
l2gw_new_name = "updated_name"
# Update l2gw name.
update_rsp = self.update_l2gw(l2gw_id, l2gw_new_name, devices)
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_200,
update_rsp.response["status"], "Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_200})
rsp_l2gw = update_rsp[constants.L2GW]
LOG.info(_LI("response : %(rsp_l2gw)s") % {"rsp_l2gw": rsp_l2gw})
# Assert if name is not updated.
self.assertEqual(
l2gw_new_name, rsp_l2gw["name"],
"l2gw name=%(rsp_name)s is not the same as "
"requested=%(name)s" % {
"rsp_name": rsp_l2gw["name"],
"name": l2gw_new_name
})
self.resource_cleanup()
def update_l2_gateway(self, l2_gateway_id, **kwargs):
uri = constants.L2_GWS_BASE_URI + "/" + l2_gateway_id
post_data = {constants.L2GW: kwargs}
constants.LOG.info(
_LI("URI : %(uri)s, posting data : %(post_data)s") % {
"uri": uri,
"post_data": post_data
})
return self.update_resource(uri, post_data)
def test_create_tap_service(self):
"""
Tap service create api is tested , Tap Service is created with
destination port associated with floating ip
"""
LOG.info(
_LI("Testing Tap Service Create api with floating ip associated to "
"destination port"))
# Create tap service env
fip, device_tap_service = self._create_tap_service_env(port_index=0)
# Create Tap Service
rsp = self.tclient.create_tap_service(**device_tap_service)
LOG.info(
_LI("response from tap serive create : %(rsp)s") % {"rsp": rsp})
self.assertEqual('201', rsp.response["status"],
"Response code is not 201 ")
self.assertIn(self.ports[0]['id'], rsp['tap_service']['port_id'])
self._resource_cleanup(fip, rsp['tap_service']['id'], 'null')
def test_l2_gateway_update_interface(self):
"""
Update l2gw will update info in already created l2gw. To
update l2gw we need l2gw id and payload to update.
"""
LOG.info(_LI("Testing l2_gateway_update api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
# Create l2gw to update l2gw name.
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_201})
devices = {"devices": [
{"device_name": device_name,
"interfaces": [{"name": "new_name",
"segmentation_id": [self.VLAN_1]}],
"deleted_interfaces": [{"name": interface_name}]}
]}
l2gw_id = rsp[constants.L2GW]["id"]
update_rsp = self.update_l2gw(l2gw_id, l2gw_name, devices)
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_200,
update_rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_200})
rsp_l2gw = update_rsp[constants.L2GW]
self.l2gw_created[rsp_l2gw["id"]] = rsp_l2gw
LOG.info(_LI("response : %(rsp_l2gw)s") % {"rsp_l2gw": rsp_l2gw})
if "segmentation_id" in devices["devices"][0]["interfaces"][0]:
self.assertEqual(devices["devices"][0]["interfaces"][0][
"segmentation_id"][0],
rsp_l2gw["devices"][0]["interfaces"][0][
"segmentation_id"][0],
"L2GW segmentation id update failed!!!")
self.resource_cleanup()
def cleanup_os_logical_ports(self):
"""
Delete all logical ports created by OpenStack
"""
lports = self.get_logical_ports()
os_lports = self.get_os_resources(lports)
LOG.info(_LI("Number of OS Logical Ports to be deleted: %s"),
len(os_lports))
# logical port vif detachment
self.update_logical_port_attachment(os_lports)
for p in os_lports:
endpoint = '/logical-ports/%s' % p['id']
response = self.delete(endpoint=endpoint)
if response.status_code == requests.codes.ok:
LOG.info(_LI("Successfully deleted logical port %s"), p['id'])
else:
LOG.error(_LE("Failed to delete lport %(port_id)s, response "
"code %(code)s"),
{'port_id': p['id'], 'code': response.status_code})
def test_exclude_list_with_single_vm_port(self):
port_client = self.manager.ports_client
self.green = self.setup_vm_enviornment(self.manager, 'green', True)
port_id = self.green['fip1']['port_id']
# Update vm port to disable port security
port_client.update_port(port_id=port_id, port_security_enabled='false')
vm_id = self.green['serv1']['id']
# Check vm in exclude list or not
items = self.vsm.get_excluded_vm_name_list()
exclude_list = [item.encode('utf-8') for item in items]
for exclude_vm in exclude_list:
if vm_id in exclude_vm:
LOG.info(_LI("Vm in exclude list"))
port_client.update_port(port_id=port_id, port_security_enabled='true')
items = self.vsm.get_excluded_vm_name_list()
exclude_list = [item.encode('utf-8') for item in items]
if exclude_vm in exclude_list:
if vm_id not in exclude_vm:
LOG.info(_LI("Vm not in exclude list"))
self.interface_client.delete_interface(vm_id, port_id)
def create_l2gw_connection(self, l2gwc_param):
"""
Creates L2GWC and return the response.
:param l2gwc_param: L2GWC parameters.
:return: response of L2GWC create API.
"""
LOG.info(_LI("l2gwc param: %(param)s ") % {"param": l2gwc_param})
l2gwc_request_body = {"l2_gateway_id": l2gwc_param["l2_gateway_id"],
"network_id": l2gwc_param["network_id"]}
if "segmentation_id" in l2gwc_param:
l2gwc_request_body["segmentation_id"] = l2gwc_param[
"segmentation_id"]
LOG.info(_LI("l2gwc_request_body: %s") % l2gwc_request_body)
rsp = self.l2gwc_client.create_l2_gateway_connection(
**l2gwc_request_body)
LOG.info(_LI("l2gwc response: %s") % rsp)
self.l2gwc_created[rsp[constants.L2GWC]["id"]] = rsp[constants.L2GWC]
return rsp
def test_show_tap_service(self):
"""
Tap Service Show api is tested
"""
LOG.info(
_LI("Testing Tap Service Show api with floating ip associated to "
"destination port "))
# Create tap service env
fip, device_tap_service = self._create_tap_service_env(port_index=0)
# Create Tap Service
rsp_create = self.tclient.create_tap_service(**device_tap_service)
# Show Tap Service
rsp_show = self.tclient.show_tap_service(
rsp_create['tap_service']['id'])
LOG.info(_LI("response from tap list : %(rsp)s") % {"rsp": rsp_show})
self.assertEqual('200', rsp_show.response["status"],
"Response code is not 200 ")
self.assertIn(device_tap_service['name'],
rsp_show['tap_service']['name'])
self.assertIn(self.ports[0]['id'], rsp_show['tap_service']['port_id'])
self._resource_cleanup(fip, rsp_create['tap_service']['id'], 'null')
def test_create_tap_flow_negative_nofloatingip(self):
"""
Tap flow create api is tested , Tap Service is created with
destination port associated to non floating ip
"""
LOG.info(
_LI("Testing Tap flow create api with non floating ip "
"associated to destination port "))
tap_service_name = data_utils.rand_name('tapservice-ch')
device_tap_service = {
"description": 'tapservice1',
"name": tap_service_name,
"port_id": self.ports[0]['id'],
"tenant_id": self.ports[0]['tenant_id']
}
# Create Tap Service
rsp_tap_service = self.tclient.create_tap_service(**device_tap_service)
LOG.info(
_LI("response from tap service : %(rsp)s") %
{"rsp": rsp_tap_service})
self.assertEqual('201', rsp_tap_service.response["status"],
"Response code is not 201 ")
tap_flow_name = data_utils.rand_name('tapflow-ch')
device_tap_flow = {
"description": 'tapflow1',
"direction": "BOTH",
"name": tap_flow_name,
"source_port": self.ports[1]['id'],
"tap_service_id": rsp_tap_service['tap_service']['id'],
"tenant_id": self.ports[0]['tenant_id']
}
# Create Tap Flow with a non floating ip associated to destination port
try:
self.tclient.create_tap_flow(**device_tap_flow)
except Exception as e:
LOG.info(_LI("response from exception %(rsp)s") % {"rsp": e})
self._resource_cleanup('null',
rsp_tap_service['tap_service']['id'],
'null')
def test_l2_gateway_update_l2gw_name(self):
"""
Update l2gw will update info in already created l2gw. To
update l2gw we need l2gw id and payload to update.
"""
LOG.info(_LI("Testing l2_gateway_update api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
# Create l2gw to update l2gw name.
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_201})
devices = {"devices": [{"device_name": device_name,
"interfaces": [{"name": interface_name}]}]
}
l2gw_id = rsp[constants.L2GW]["id"]
l2gw_new_name = "updated_name"
# Update l2gw name.
update_rsp = self.update_l2gw(l2gw_id, l2gw_new_name, devices)
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_200,
update_rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_200})
rsp_l2gw = update_rsp[constants.L2GW]
LOG.info(_LI("response : %(rsp_l2gw)s") % {"rsp_l2gw": rsp_l2gw})
# Assert if name is not updated.
self.assertEqual(l2gw_new_name, rsp_l2gw["name"],
"l2gw name=%(rsp_name)s is not the same as "
"requested=%(name)s" % {"rsp_name": rsp_l2gw["name"],
"name": l2gw_new_name})
self.resource_cleanup()
def test_delete_tap_service(self):
"""
Tap Service Delete api is tested
"""
LOG.info(
_LI("Testing Tap delete api with floating ip associated "
"to destination port "))
# Create tap service env
fip, device_tap_service = self._create_tap_service_env(port_index=0)
# Create Tap Service
rsp_create = self.tclient.create_tap_service(**device_tap_service)
LOG.info(_LI("response from tap list : %(rsp)s") % {"rsp": rsp_create})
self.assertEqual('201', rsp_create.response["status"],
"Response code is not 201 ")
# Delete Tap Service
rsp_delete = self.tclient.delete_tap_service(
rsp_create['tap_service']['id'])
self.assertEqual('204', rsp_delete.response["status"],
"Response code is not 204 ")
rsp_list = self.tclient.list_tap_service()
LOG.info(_LI("response from tap list : %(rsp)s") % {"rsp": rsp_list})
self._resource_cleanup(fip, 'null', 'null')
def cleanup_os_logical_ports(self):
"""
Delete all logical ports created by OpenStack
"""
lports = self.get_logical_ports()
os_lports = self.get_os_resources(lports)
LOG.info(_LI("Number of OS Logical Ports to be deleted: %s"),
len(os_lports))
# logical port vif detachment
self.update_logical_port_attachment(os_lports)
for p in os_lports:
endpoint = '/logical-ports/%s' % p['id']
response = self.delete(endpoint=endpoint)
if response.status_code == requests.codes.ok:
LOG.info(_LI("Successfully deleted logical port %s"), p['id'])
else:
LOG.error(
_LE("Failed to delete lport %(port_id)s, response "
"code %(code)s"), {
'port_id': p['id'],
'code': response.status_code
})
def test_l2_gateway_create(self):
"""
Create l2gw based on UUID and bridge cluster name. It creates l2gw.
To create l2gw we need bridge cluster name (interface name) and
bridge cluster UUID (device name) from NSX manager.
"""
LOG.info(_LI("Testing l2_gateway_create api"))
device_name, interface_name = self.nsx_bridge_cluster_info()
l2gw_name = data_utils.rand_name(constants.L2GW)
devices = {"devices": [{"device_name": device_name,
"interfaces": [{"name": interface_name}]}]
}
self.operate_l2gw(name=l2gw_name, devices=devices, task="create")
self.resource_cleanup()
def test_create_tap_flow_negative_nosrcport(self):
"""
Tap flow create api is tested with non existent src port
"""
LOG.info(
_LI("Testing Tap flow create api with non existent src port "))
tap_service_name = data_utils.rand_name('tapservice-ch')
device_tap_service = {
"description": 'tapservice1',
"name": tap_service_name,
"port_id": self.ports[0]['id'],
"tenant_id": self.ports[0]['tenant_id']
}
# Create Tap Service
rsp_tap_service = self.tclient.create_tap_service(**device_tap_service)
LOG.info(
_LI("response from tap service : %(rsp)s") %
{"rsp": rsp_tap_service})
self.assertEqual('201', rsp_tap_service.response["status"],
"Response code is not 201 ")
tap_flow_name = data_utils.rand_name('tapflow-ch')
device_tap_flow = {
"description": 'tapflow1',
"direction": "BOTH",
"name": tap_flow_name,
"source_port": '2ad76061-252e-xxxx-9d0f-dd94188be9cc',
"tap_service_id": rsp_tap_service['tap_service']['id'],
"tenant_id": self.ports[0]['tenant_id']
}
# Create Tap Flow with a dummy non existent source port
try:
self.tclient.create_tap_flow(**device_tap_flow)
except Exception as e:
LOG.info(_LI("response from exception %(rsp)s") % {"rsp": e})
self._resource_cleanup('null',
rsp_tap_service['tap_service']['id'],
'null')
def test_create_l2gw_with_non_int_seg_id(self):
"""
Create l2 gateway connection using invalid seg id.
"""
LOG.info(_LI("Testing l2_gateway_create api with segmentation ID"))
invalid_seg_id = 2.45
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name,
"vlans": [invalid_seg_id]}
l2gw_param = [device_1]
self.assertRaises(lib_exc.BadRequest, self.create_l2gw, l2gw_name,
l2gw_param)
self.addCleanup(self.l2gw_cleanup)
def test_l2_gateway_delete(self):
"""
Delete l2gw will create l2gw and delete recently created l2gw. To
delete l2gw we need l2gw id.
"""
LOG.info(_LI("Testing l2_gateway_delete api"))
device_name, interface_name = self.nsx_bridge_cluster_info()
l2gw_name = data_utils.rand_name(constants.L2GW)
devices = {"devices": [{"device_name": device_name,
"interfaces": [{"name": interface_name}]}]
}
# Creating l2gw.
self.operate_l2gw(name=l2gw_name, devices=devices, task="create")
# Deleting already created l2gw.
self.operate_l2gw(name=l2gw_name, devices=devices, task="delete")
self.resource_cleanup()
def test_l2_gateway_connection_show(self):
"""
Create l2 gateway connection using one vlan and tes l2 gateway
connection show api
"""
LOG.info(_LI("Testing test_l2_gateway_connection_create api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
l2gw_rsp, _ = self.create_l2gw(l2gw_name, l2gw_param)
l2gwc_param = {
"l2_gateway_id": l2gw_rsp[constants.L2GW]["id"],
"network_id": self.network["id"],
"segmentation_id": self.VLAN_1
}
l2gwc_rsp = self.create_l2gw_connection(l2gwc_param)
# Assert if create fails.
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_201, l2gwc_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_201})
l2gwc_id = l2gwc_rsp[constants.L2GWC]["id"]
show_rsp = self.l2gwc_client.show_l2_gateway_connection(l2gwc_id)
self.assertEqual(
constants.EXPECTED_HTTP_RESPONSE_200, show_rsp.response["status"],
"Response code is not %(code)s" %
{"code": constants.EXPECTED_HTTP_RESPONSE_200})
self.assertEqual(
l2gwc_param["l2_gateway_id"],
show_rsp[constants.L2GWC]["l2_gateway_id"],
"l2gw id is not same as expected in "
"show l2gw connection response")
self.assertEqual(
l2gwc_param["network_id"], show_rsp[constants.L2GWC]["network_id"],
"network id is not same as expected in "
"show l2gw connection response")
show_rsp_seg_id = str(show_rsp[constants.L2GWC]["segmentation_id"])
self.assertEqual(
l2gwc_param["segmentation_id"], show_rsp_seg_id,
"segmentation id is not same as expected in "
"show l2gw connection response")
self.addCleanup(self.l2gw_cleanup)
def test_create_l2gwc_with_nonexist_network(self):
"""
Create l2 gateway connection using non exist l2gw uuid.
"""
LOG.info(_LI("Testing test_l2_gateway_connection_create api"))
non_exist_network_uuid = NON_EXIST_UUID
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
l2gw_rsp, _ = self.create_l2gw(l2gw_name, l2gw_param)
l2gwc_param = {"l2_gateway_id": l2gw_rsp[constants.L2GW]["id"],
"network_id": non_exist_network_uuid,
"segmentation_id": self.VLAN_1}
# Delete l2gw must raise Conflict exception.
self.assertRaises(lib_exc.NotFound, self.create_l2gw_connection,
l2gwc_param)
self.addCleanup(self.l2gw_cleanup)
def get_nsx_resource_by_name(self, nsx_resources, nsx_name):
"""
Get the NSX component created from OpenStack by name.
The name should be converted from os_name to nsx_name.
If found exact one match return it, otherwise report error.
"""
nsx_resource = [n for n in nsx_resources if
n['display_name'] == nsx_name]
if len(nsx_resource) == 0:
LOG.warning(_LW("Backend nsx resource %s NOT found!"), nsx_name)
return None
if len(nsx_resource) > 1:
LOG.error(_LE("More than 1 nsx resources found: %s!"),
nsx_resource)
return None
else:
LOG.info(_LI("Found nsgroup: %s"), nsx_resource[0])
return nsx_resource[0]
def test_l2_gateway_show(self):
"""
show l2gw based on UUID. To see l2gw info we need l2gw id.
"""
LOG.info(_LI("Testing l2_gateway_show api"))
device_name, interface_name = self.nsx_bridge_cluster_info()
l2gw_name = data_utils.rand_name(constants.L2GW)
devices = {"devices": [
{"device_name": device_name,
"interfaces": [{"name": interface_name,
"segmentation_id": [
self.VLAN_1,
self.VLAN_2]}]
}]
}
# Creating l2gw.
self.operate_l2gw(name=l2gw_name, devices=devices, task="create")
# Show already created l2gw with l2gw id.
self.operate_l2gw(name=l2gw_name, devices=devices, task="show")
self.resource_cleanup()
def get_nsx_resource_by_name(self, nsx_resources, nsx_name):
"""
Get the NSX component created from OpenStack by name.
The name should be converted from os_name to nsx_name.
If found exact one match return it, otherwise report error.
"""
nsx_resource = [
n for n in nsx_resources if n['display_name'] == nsx_name
]
if len(nsx_resource) == 0:
LOG.warning(_LW("Backend nsx resource %s NOT found!"), nsx_name)
return None
if len(nsx_resource) > 1:
LOG.error(_LE("More than 1 nsx resources found: %s!"),
nsx_resource)
return None
else:
LOG.info(_LI("Found nsgroup: %s"), nsx_resource[0])
return nsx_resource[0]
def test_l2_gateway_show(self):
"""
show l2gw based on UUID. To see l2gw info we need l2gw id.
"""
LOG.info(_LI("Testing l2_gateway_show api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name,
"vlans": [self.VLAN_1, self.VLAN_2]}
l2gw_param = [device_1]
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
rsp.response["status"],
"Response code is not %(code)s" % {
"code": constants.EXPECTED_HTTP_RESPONSE_201})
l2gw_id = rsp[constants.L2GW]["id"]
l2gw_id = str(l2gw_id)
show_rsp = self.l2gw_client.show_l2_gateway(l2gw_id)
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_200,
show_rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_200})
show_rsp = show_rsp[constants.L2GW]["devices"]
rsp = rsp[constants.L2GW]["devices"]
self.assertEqual(rsp[0]["device_name"],
show_rsp[0]["device_name"],
"Device name is not the same as expected")
self.assertEqual(
rsp[0]["interfaces"][0]["name"],
show_rsp[0]["interfaces"][0]["name"],
"Interface name is not the same as expected")
requested_vlans = \
rsp[0]["interfaces"][0]["segmentation_id"]
response_vlans = show_rsp[0]["interfaces"][0]["segmentation_id"]
for id in requested_vlans:
self.assertIn(id, response_vlans)
self.resource_cleanup()
def test_l2_gateway_create_without_vlan(self):
"""
Create l2gw based on UUID and bridge cluster name. It creates l2gw.
To create l2gw we need bridge cluster name (interface name) and
bridge cluster UUID (device name) from NSX manager.
"""
LOG.info(_LI("Testing l2_gateway_create api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
rsp, requested_devices = self.create_l2gw(l2gw_name, l2gw_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
rsp.response["status"],
"Response code is not %(code)s" % {
"code": constants.EXPECTED_HTTP_RESPONSE_201})
self.assertEqual(requested_devices[0]["device_name"],
rsp[constants.L2GW]["devices"][0]["device_name"],
"Device name is not the same as expected")
self.resource_cleanup()
def test_recreate_l2_gateway_connection(self):
"""
Recreate l2 gateway connection using same parameters.
"""
LOG.info(_LI("Testing test_l2_gateway_connection_create api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name,
"vlans": [self.VLAN_1]}
l2gw_param = [device_1]
l2gw_rsp, _ = self.create_l2gw(l2gw_name, l2gw_param)
l2gwc_param = {"l2_gateway_id": l2gw_rsp[constants.L2GW]["id"],
"network_id": self.network["id"]}
l2gwc_rsp = self.create_l2gw_connection(l2gwc_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
l2gwc_rsp.response["status"],
"Response code is not %(code)s" % {
"code": constants.EXPECTED_HTTP_RESPONSE_201})
self.assertRaises(lib_exc.Conflict, self.create_l2gw_connection,
l2gwc_param)
self.addCleanup(self.l2gw_cleanup)
def test_active_l2_gateway_delete(self):
"""
Delete l2 gateway with active mapping.
"""
LOG.info(_LI("Testing test_l2_gateway_create api"))
cluster_info = self.nsx_bridge_cluster_info()
device_name, interface_name = cluster_info[0][0], cluster_info[0][1]
l2gw_name = data_utils.rand_name(constants.L2GW)
device_1 = {"dname": device_name, "iname": interface_name}
l2gw_param = [device_1]
l2gw_rsp, _ = self.create_l2gw(l2gw_name, l2gw_param)
l2gwc_param = {"l2_gateway_id": l2gw_rsp[constants.L2GW]["id"],
"network_id": self.network["id"],
"segmentation_id": self.VLAN_1}
l2gwc_rsp = self.create_l2gw_connection(l2gwc_param)
# Assert if create fails.
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
l2gwc_rsp.response["status"],
"Response code is not %(code)s" % {
"code": constants.EXPECTED_HTTP_RESPONSE_201})
l2gw_id = l2gw_rsp[constants.L2GW]["id"]
# Delete l2gw must raise Conflict exception.
self.assertRaises(lib_exc.Conflict, self.delete_l2gw, l2gw_id)
self.addCleanup(self.l2gw_cleanup)
def test_create_update_nsx_security_group(self):
# Create a security group
group_create_body, name = self._create_security_group()
secgroup = group_create_body['security_group']
time.sleep(NSX_FIREWALL_REALIZED_DELAY)
LOG.info(_LI("Create security group with name %(name)s and id %(id)s"),
{'name': secgroup['name'], 'id': secgroup['id']})
# List security groups and verify if created group is there in response
list_body = self.security_groups_client.list_security_groups()
secgroup_list = list()
for sg in list_body['security_groups']:
secgroup_list.append(sg['id'])
self.assertIn(secgroup['id'], secgroup_list)
nsx_nsgroup = self.nsx.get_ns_group(secgroup['name'], secgroup['id'])
nsx_dfw_section = self.nsx.get_firewall_section(secgroup['name'],
secgroup['id'])
self.assertIsNotNone(nsx_nsgroup)
self.assertIsNotNone(nsx_dfw_section)
# Update the security group
new_name = data_utils.rand_name('security-')
new_description = data_utils.rand_name('security-description')
update_body = self.security_groups_client.update_security_group(
secgroup['id'],
name=new_name,
description=new_description)
# Verify if security group is updated
updated_secgroup = update_body['security_group']
self.assertEqual(updated_secgroup['name'], new_name)
self.assertEqual(updated_secgroup['description'], new_description)
nsx_nsgroup = self.nsx.get_ns_group(updated_secgroup['name'],
updated_secgroup['id'])
nsx_dfw_section = self.nsx.get_firewall_section(
new_name, secgroup['id'])
self.assertIsNotNone(nsx_nsgroup)
self.assertIsNotNone(nsx_dfw_section,
"Firewall section %s is not updated!")
def list_l2_gateways(self, **filters):
uri = constants.L2_GWS_BASE_URI
LOG.info(_LI("URI : %(uri)s") % {"uri": uri})
return self.list_resources(uri, **filters)
def delete_l2_gateway(self, l2_gateway_id):
uri = constants.L2_GWS_BASE_URI + "/" + l2_gateway_id
LOG.info(_LI("URI : %(uri)s") % {"uri": uri})
return self.delete_resource(uri)
def operate_l2gw(self, name, devices, task):
"""
l2gw operations such create, delete, update and show.
:param name: l2gw name.
:param devices: l2gw parameters information.
:param task: Operation to perform.
"""
LOG.info(_LI("name: %(name)s, devices: %(devices)s, "
"task: %(task)s") %
{"name": name, "devices": devices, "task": task})
if task == "create":
rsp = self.l2gw_client.create_l2_gateway(
name=name, **devices)
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_201,
rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_201})
rsp_l2gw = rsp[constants.L2GW]
self.l2gw_created[rsp_l2gw["id"]] = rsp_l2gw
LOG.info(_LI("response : %(rsp_l2gw)s") % {"rsp_l2gw": rsp_l2gw})
self.assertEqual(name, rsp_l2gw["name"],
"l2gw name=%(rsp_name)s is not the same as "
"requested=%(name)s" % {"rsp_name": rsp_l2gw[
"name"], "name": name})
elif task == "delete":
l2gw_id, _ = self.l2gw_created.popitem()
rsp = self.l2gw_client.delete_l2_gateway(l2gw_id)
LOG.info(_LI("response : %(rsp)s") % {"rsp": rsp})
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_204,
rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_204})
elif task == "update":
l2gw_id, _ = self.l2gw_created.popitem()
rsp = self.l2gw_client.update_l2_gateway(l2gw_id,
name=name, **devices)
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_200,
rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_200})
rsp_l2gw = rsp[constants.L2GW]
self.l2gw_created[rsp_l2gw["id"]] = rsp_l2gw
LOG.info(_LI("response : %(rsp_l2gw)s") % {"rsp_l2gw": rsp_l2gw})
self.assertEqual(name, rsp_l2gw["name"],
"l2gw name=%(rsp_name)s is not the same as "
"requested=%(name)s" % {
"rsp_name": rsp_l2gw["name"], "name": name})
if "name" in devices["devices"][0]["interfaces"][0]:
self.assertEqual(
devices["devices"][0]["interfaces"][0]["name"],
rsp_l2gw["devices"][0]["interfaces"][0][
"name"], "L2GW interface name update "
"failed!!!")
if "segmentation_id" in devices["devices"][0]["interfaces"][0]:
self.assertEqual(devices["devices"][0]["interfaces"][0][
"segmentation_id"][0],
rsp_l2gw["devices"][0]["interfaces"][0][
"segmentation_id"][0],
"L2GW segmentation id update failed!!!")
elif task == "show":
l2gw_id, l2gw_parameters = self.l2gw_created.popitem()
rsp = self.l2gw_client.show_l2_gateway(l2gw_id)
self.assertEqual(constants.EXPECTED_HTTP_RESPONSE_200,
rsp.response["status"],
"Response code is not %(code)s" % {
"code":
constants.EXPECTED_HTTP_RESPONSE_200})
rsp_l2gw = rsp[constants.L2GW]
constants.LOG.info(
_LI("response : %(rsp_l2gw)s") % {"rsp_l2gw": rsp_l2gw})
self.assertEqual(name, rsp_l2gw["name"],
"l2gw name=%(rsp_name)s is not the same as "
"requested=%(name)s" % {
"rsp_name": rsp_l2gw["name"],
"name": name})
self.assertEqual(l2gw_parameters, rsp_l2gw,
"l2-gateway-show does not show parameter as it "
"was created.")
self.l2gw_created[l2gw_id] = l2gw_parameters
def show_l2_gateway(self, l2_gateway_id, **fields):
uri = constants.L2_GWS_BASE_URI + "/" + l2_gateway_id
LOG.info(_LI("URI : %(uri)s") % {"uri": uri})
return self.show_resource(uri, **fields)
