class TestNeutronDriver(base.TestCase):
def setUp(self):
super(TestNeutronDriver, self).setUp()
self.neutron_client = mock.MagicMock()
self.neutron_client.list_networks.return_value = network_response
self.neutron_client.list_ports.return_value = port_response
self.neutron_client.list_routers.return_value = router_response
self.neutron_client.list_security_groups.return_value = \
security_group_response
args = helper.datasource_openstack_args()
args['poll_time'] = 0
self.driver = NeutronDriver(args=args)
def test_list_networks(self):
"""Test conversion of complex network objects to tables."""
network_list = self.neutron_client.list_networks()
self.driver._translate_networks(network_list)
network_tuples = self.driver.state[self.driver.NETWORKS]
network_subnet_tuples = self.driver.state[
self.driver.NETWORKS_SUBNETS]
# size of networks/subnets
self.assertIsNotNone(network_tuples)
self.assertEquals(1, len(network_tuples))
self.assertEquals(1, len(network_subnet_tuples))
# properties of first network
key_to_index = self.driver.get_column_map(
self.driver.NETWORKS)
network_tuple = network_tuples.pop()
subnet_tuple_guid = network_tuple[key_to_index['subnets']]
name = network_tuple[key_to_index['name']]
status = network_tuple[key_to_index['status']]
provider_physical_network = \
network_tuple[key_to_index['provider:physical_network']]
admin_state_up = network_tuple[key_to_index['admin_state_up']]
tenant_id = network_tuple[key_to_index['tenant_id']]
provider_network_type = \
network_tuple[key_to_index['provider:network_type']]
router_external = network_tuple[key_to_index['router:external']]
shared = network_tuple[key_to_index['shared']]
id = network_tuple[key_to_index['id']]
provider_segmentation_id = \
network_tuple[key_to_index['provider:segmentation_id']]
# properties of first subnet
network_subnet_tuple = network_subnet_tuples.pop()
guid_key = network_subnet_tuple[0]
guid_value = network_subnet_tuple[1]
# tests for network/subnet
self.assertEquals('ACTIVE', status)
self.assertIsNotNone(subnet_tuple_guid)
self.assertEqual(guid_key, subnet_tuple_guid)
self.assertEqual('4cef03d0-1d02-40bb-8c99-2f442aac6ab0',
guid_value)
self.assertEquals('test-network',
name)
self.assertEquals('None', provider_physical_network)
self.assertEquals('True', admin_state_up)
self.assertEquals('570fe78a1dc54cffa053bd802984ede2',
tenant_id)
self.assertEquals('gre', provider_network_type)
self.assertEquals('False', router_external)
self.assertEquals('False', shared)
self.assertEquals('240ff9df-df35-43ae-9df5-27fae87f2492',
id)
self.assertEquals(4, provider_segmentation_id)
def test_list_ports(self):
"""Test conversion of complex port objects to tuples."""
# setup
self.driver._translate_ports(self.neutron_client.list_ports())
d = self.driver.get_column_map(self.driver.PORTS)
# number of ports
ports = self.driver.state[self.driver.PORTS]
self.assertIsNotNone(ports)
self.assertEquals(1, len(ports))
# simple properties of a port
port = ports.pop()
self.assertEqual('ACTIVE', port[d['status']])
self.assertEqual('havana', port[d['binding:host_id']])
self.assertEqual('', port[d['name']])
self.assertEqual('True', port[d['admin_state_up']])
self.assertEqual('240ff9df-df35-43ae-9df5-27fae87f2492',
port[d['network_id']])
self.assertEqual('570fe78a1dc54cffa053bd802984ede2',
port[d['tenant_id']])
self.assertEqual('ovs', port[d['binding:vif_type']])
self.assertEqual('network:router_interface', port[d['device_owner']])
self.assertEqual('fa:16:3e:ab:90:df', port[d['mac_address']])
self.assertEqual('0a2ce569-85a8-45ec-abb3-0d4b34ff69ba',
port[d['id']])
self.assertEqual('864e4acf-bf8e-4664-8cf7-ad5daa95681e',
port[d['device_id']])
# complex property: allowed_address_pairs
# TODO(thinrichs): add representative allowed_address_pairs
address_pairs = self.driver.state[
self.driver.PORTS_ADDR_PAIRS]
self.assertEqual(0, len(address_pairs))
# complex property: extra_dhcp_opts
# TODO(thinrichs): add representative port_extra_dhcp_opts
dhcp_opts = self.driver.state[
self.driver.PORTS_EXTRA_DHCP_OPTS]
self.assertEqual(0, len(dhcp_opts))
# complex property: binding:capabilities
binding_caps = self.driver.state[
self.driver.PORTS_BINDING_CAPABILITIES]
cap_id = port[d['binding:capabilities']]
self.assertEqual(1, len(binding_caps))
self.assertEqual((cap_id, 'port_filter', 'True'), binding_caps.pop())
# complex property: security_groups
sec_grps = self.driver.state[self.driver.PORTS_SECURITY_GROUPS]
self.assertEqual(2, len(sec_grps))
security_grp_grp = port[d['security_groups']]
security_grp1 = '15ea0516-11ec-46e9-9e8e-7d1b6e3d7523'
security_grp2 = '25ea0516-11ec-46e9-9e8e-7d1b6e3d7523'
security_data = set([(security_grp_grp, security_grp1),
(security_grp_grp, security_grp2)])
self.assertEqual(security_data, set(sec_grps))
# complex property: fixed_ips
# Need to show we have the following
# port(..., <fixed_ips>, ...)
# fixed_ips_groups(<fixed_ips>, <fip1>)
# fixed_ips_groups(<fixed_ips>, <fip2>)
# fixedips(<fip1>, "subnet_id", "4cef03d0-1d02-40bb-8c99-2f442aac6ab0")
# fixedips(<fip1>, "ip_address", "90.0.0.1")
# fixedips(<fip2>, "subnet_id", "5cef03d0-1d02-40bb-8c99-2f442aac6ab0")
# fixedips(<fip2>, "ip_address", "100.0.0.1")
# TODO(thinrichs): use functionality of policy-engine
# to make this test simpler to understand/write
fixed_ip_groups = self.driver.state[
self.driver.PORTS_FIXED_IPS_GROUPS]
fixed_ips = self.driver.state[self.driver.PORTS_FIXED_IPS]
fixed_ip_grp = port[d['fixed_ips']]
# ensure groups of IPs are correct
self.assertEqual(2, len(fixed_ip_groups))
groups = set([x[0] for x in fixed_ip_groups])
self.assertEqual(set([fixed_ip_grp]), groups)
# ensure the IDs for fixed_ips are the right ones
fixed_ips_from_grp = [x[1] for x in fixed_ip_groups]
fixed_ips_from_ips = [x[0] for x in fixed_ips]
self.assertEqual(set(fixed_ips_from_grp), set(fixed_ips_from_ips))
# ensure actual fixed_ips are right
self.assertEqual(4, len(fixed_ips))
ips = [x for x in fixed_ips if x[1] == 'ip_address']
subnets = [x for x in fixed_ips if x[1] == 'subnet_id']
if ips[0][0] == subnets[0][0]:
ip0 = ips[0][2]
subnet0 = subnets[0][2]
ip1 = ips[1][2]
subnet1 = subnets[1][2]
else:
ip0 = ips[0][2]
subnet0 = subnets[1][2]
ip1 = ips[1][2]
subnet1 = subnets[0][2]
if ip0 == "90.0.0.1":
self.assertEqual("4cef03d0-1d02-40bb-8c99-2f442aac6ab0", subnet0)
self.assertEqual("90.0.0.1", ip0)
self.assertEqual("5cef03d0-1d02-40bb-8c99-2f442aac6ab0", subnet1)
self.assertEqual("100.0.0.1", ip1)
else:
self.assertEqual("4cef03d0-1d02-40bb-8c99-2f442aac6ab0", subnet1)
self.assertEqual("90.0.0.1", ip1)
self.assertEqual("5cef03d0-1d02-40bb-8c99-2f442aac6ab0", subnet0)
self.assertEqual("100.0.0.1", ip0)
def test_list_routers(self):
self.driver._translate_routers(self.neutron_client.list_routers())
d = self.driver.get_column_map(self.driver.ROUTERS)
# number of routers
routers = self.driver.state[self.driver.ROUTERS]
self.assertIsNotNone(routers)
self.assertEquals(1, len(routers))
# simple properties of a router
router = routers.pop()
self.assertEqual('ACTIVE', router[d['status']])
self.assertEqual('router1', router[d['name']])
self.assertEqual('True', router[d['admin_state_up']])
self.assertEqual('abb53cc6636848218f46d01f22bf1060',
router[d['tenant_id']])
self.assertEqual('4598c424-d608-4366-9beb-139adbd7cff5',
router[d['id']])
# external gateway info
gateway_info = self.driver.state[
self.driver.ROUTERS_EXTERNAL_GATEWAYS]
gateway_id = router[d['external_gateway_info']]
self.assertEqual(2, len(gateway_info))
row1 = (gateway_id, 'network_id',
'a821b8d3-af1f-4d79-9b8e-3da9674338ae')
row2 = (gateway_id, 'enable_snat', 'True')
self.assertEqual(set([row1, row2]), gateway_info)
def test_list_security_groups(self):
self.driver._translate_security_groups(
self.neutron_client.list_security_groups())
d = self.driver.get_column_map(self.driver.SECURITY_GROUPS)
# number of security groups
sec_grps = self.driver.state[self.driver.SECURITY_GROUPS]
self.assertIsNotNone(sec_grps)
self.assertEquals(1, len(sec_grps))
# simple properties
sec_grp = sec_grps.pop()
self.assertEqual('abb53cc6636848218f46d01f22bf1060',
sec_grp[d['tenant_id']])
self.assertEqual('default', sec_grp[d['name']])
self.assertEqual('default', sec_grp[d['description']])
self.assertEqual('9f3860a5-87b1-499c-bf93-5ca3ef247517',
sec_grp[d['id']])
