240 lines
10 KiB
Python
240 lines
10 KiB
Python
import unittest
|
|
from mock import patch
|
|
from nose.tools import raises
|
|
import charmhelpers.contrib.openstack.neutron as neutron
|
|
|
|
TO_PATCH = [
|
|
'log',
|
|
'config',
|
|
'os_release',
|
|
'check_output',
|
|
]
|
|
|
|
|
|
class NeutronTests(unittest.TestCase):
|
|
def setUp(self):
|
|
for m in TO_PATCH:
|
|
setattr(self, m, self._patch(m))
|
|
|
|
def _patch(self, method):
|
|
_m = patch('charmhelpers.contrib.openstack.neutron.' + method)
|
|
mock = _m.start()
|
|
self.addCleanup(_m.stop)
|
|
return mock
|
|
|
|
def test_headers_package(self):
|
|
self.check_output.return_value = b'3.13.0-19-generic'
|
|
kname = neutron.headers_package()
|
|
self.assertEquals(kname, 'linux-headers-3.13.0-19-generic')
|
|
|
|
def test_kernel_version(self):
|
|
self.check_output.return_value = b'3.13.0-19-generic'
|
|
kver_maj, kver_min = neutron.kernel_version()
|
|
self.assertEquals((kver_maj, kver_min), (3, 13))
|
|
|
|
@patch.object(neutron, 'kernel_version')
|
|
def test_determine_dkms_package_old_kernel(self, _kernel_version):
|
|
self.check_output.return_value = b'3.4.0-19-generic'
|
|
_kernel_version.return_value = (3, 10)
|
|
dkms_package = neutron.determine_dkms_package()
|
|
self.assertEquals(dkms_package, ['linux-headers-3.4.0-19-generic',
|
|
'openvswitch-datapath-dkms'])
|
|
|
|
@patch.object(neutron, 'kernel_version')
|
|
def test_determine_dkms_package_new_kernel(self, _kernel_version):
|
|
_kernel_version.return_value = (3, 13)
|
|
dkms_package = neutron.determine_dkms_package()
|
|
self.assertEquals(dkms_package, [])
|
|
|
|
def test_quantum_plugins(self):
|
|
self.config.return_value = 'foo'
|
|
plugins = neutron.quantum_plugins()
|
|
self.assertEquals(plugins['ovs']['services'],
|
|
['quantum-plugin-openvswitch-agent'])
|
|
self.assertEquals(plugins['nvp']['services'], [])
|
|
|
|
def test_neutron_plugins_preicehouse(self):
|
|
self.config.return_value = 'foo'
|
|
self.os_release.return_value = 'havana'
|
|
plugins = neutron.neutron_plugins()
|
|
self.assertEquals(plugins['ovs']['config'],
|
|
'/etc/neutron/plugins/openvswitch/ovs_neutron_plugin.ini')
|
|
self.assertEquals(plugins['nvp']['services'], [])
|
|
|
|
def test_neutron_plugins(self):
|
|
self.config.return_value = 'foo'
|
|
self.os_release.return_value = 'icehouse'
|
|
plugins = neutron.neutron_plugins()
|
|
self.assertEquals(plugins['ovs']['config'],
|
|
'/etc/neutron/plugins/ml2/ml2_conf.ini')
|
|
self.assertEquals(plugins['nvp']['config'],
|
|
'/etc/neutron/plugins/vmware/nsx.ini')
|
|
self.assertTrue('neutron-plugin-vmware' in
|
|
plugins['nvp']['server_packages'])
|
|
self.assertEquals(plugins['n1kv']['config'],
|
|
'/etc/neutron/plugins/cisco/cisco_plugins.ini')
|
|
self.assertEquals(plugins['Calico']['config'],
|
|
'/etc/neutron/plugins/ml2/ml2_conf.ini')
|
|
self.assertEquals(plugins['plumgrid']['config'],
|
|
'/etc/neutron/plugins/plumgrid/plumgrid.ini')
|
|
self.assertEquals(plugins['midonet']['config'],
|
|
'/etc/neutron/plugins/midonet/midonet.ini')
|
|
|
|
self.assertEquals(plugins['nvp']['services'], [])
|
|
self.assertEquals(plugins['nsx'], plugins['nvp'])
|
|
|
|
self.os_release.return_value = 'kilo'
|
|
plugins = neutron.neutron_plugins()
|
|
self.assertEquals(plugins['midonet']['driver'],
|
|
'neutron.plugins.midonet.plugin.MidonetPluginV2')
|
|
self.assertEquals(plugins['nsx']['config'],
|
|
'/etc/neutron/plugins/vmware/nsx.ini')
|
|
|
|
self.os_release.return_value = 'liberty'
|
|
self.config.return_value = 'mem-1.9'
|
|
plugins = neutron.neutron_plugins()
|
|
self.assertEquals(plugins['midonet']['driver'],
|
|
'midonet.neutron.plugin_v1.MidonetPluginV2')
|
|
self.assertTrue('python-networking-midonet' in
|
|
plugins['midonet']['server_packages'])
|
|
|
|
self.os_release.return_value = 'mitaka'
|
|
self.config.return_value = 'mem-1.9'
|
|
plugins = neutron.neutron_plugins()
|
|
self.assertEquals(plugins['nsx']['config'],
|
|
'/etc/neutron/nsx.ini')
|
|
self.assertTrue('python-vmware-nsx' in
|
|
plugins['nsx']['server_packages'])
|
|
|
|
@patch.object(neutron, 'network_manager')
|
|
def test_neutron_plugin_attribute_quantum(self, _network_manager):
|
|
self.config.return_value = 'foo'
|
|
_network_manager.return_value = 'quantum'
|
|
plugins = neutron.neutron_plugin_attribute('ovs', 'services')
|
|
self.assertEquals(plugins, ['quantum-plugin-openvswitch-agent'])
|
|
|
|
@patch.object(neutron, 'network_manager')
|
|
def test_neutron_plugin_attribute_neutron(self, _network_manager):
|
|
self.config.return_value = 'foo'
|
|
self.os_release.return_value = 'icehouse'
|
|
_network_manager.return_value = 'neutron'
|
|
plugins = neutron.neutron_plugin_attribute('ovs', 'services')
|
|
self.assertEquals(plugins, ['neutron-plugin-openvswitch-agent'])
|
|
|
|
@raises(Exception)
|
|
@patch.object(neutron, 'network_manager')
|
|
def test_neutron_plugin_attribute_foo(self, _network_manager):
|
|
_network_manager.return_value = 'foo'
|
|
self.assertRaises(Exception, neutron.neutron_plugin_attribute('ovs', 'services'))
|
|
|
|
@raises(Exception)
|
|
@patch.object(neutron, 'network_manager')
|
|
def test_neutron_plugin_attribute_plugin_keyerror(self, _network_manager):
|
|
self.config.return_value = 'foo'
|
|
_network_manager.return_value = 'quantum'
|
|
self.assertRaises(Exception, neutron.neutron_plugin_attribute('foo', 'foo'))
|
|
|
|
@patch.object(neutron, 'network_manager')
|
|
def test_neutron_plugin_attribute_attr_keyerror(self, _network_manager):
|
|
self.config.return_value = 'foo'
|
|
_network_manager.return_value = 'quantum'
|
|
plugins = neutron.neutron_plugin_attribute('ovs', 'foo')
|
|
self.assertEquals(plugins, None)
|
|
|
|
@raises(Exception)
|
|
def test_network_manager_essex(self):
|
|
essex_cases = {
|
|
'quantum': 'quantum',
|
|
'neutron': 'quantum',
|
|
'newhotness': 'newhotness',
|
|
}
|
|
self.os_release.return_value = 'essex'
|
|
for nwmanager in essex_cases:
|
|
self.config.return_value = nwmanager
|
|
self.assertRaises(Exception, neutron.network_manager())
|
|
|
|
def test_network_manager_folsom(self):
|
|
folsom_cases = {
|
|
'quantum': 'quantum',
|
|
'neutron': 'quantum',
|
|
'newhotness': 'newhotness',
|
|
}
|
|
self.os_release.return_value = 'folsom'
|
|
for nwmanager in folsom_cases:
|
|
self.config.return_value = nwmanager
|
|
renamed_manager = neutron.network_manager()
|
|
self.assertEquals(renamed_manager, folsom_cases[nwmanager])
|
|
|
|
def test_network_manager_grizzly(self):
|
|
grizzly_cases = {
|
|
'quantum': 'quantum',
|
|
'neutron': 'quantum',
|
|
'newhotness': 'newhotness',
|
|
}
|
|
self.os_release.return_value = 'grizzly'
|
|
for nwmanager in grizzly_cases:
|
|
self.config.return_value = nwmanager
|
|
renamed_manager = neutron.network_manager()
|
|
self.assertEquals(renamed_manager, grizzly_cases[nwmanager])
|
|
|
|
def test_network_manager_havana(self):
|
|
havana_cases = {
|
|
'quantum': 'neutron',
|
|
'neutron': 'neutron',
|
|
'newhotness': 'newhotness',
|
|
}
|
|
self.os_release.return_value = 'havana'
|
|
for nwmanager in havana_cases:
|
|
self.config.return_value = nwmanager
|
|
renamed_manager = neutron.network_manager()
|
|
self.assertEquals(renamed_manager, havana_cases[nwmanager])
|
|
|
|
def test_network_manager_icehouse(self):
|
|
icehouse_cases = {
|
|
'quantum': 'neutron',
|
|
'neutron': 'neutron',
|
|
'newhotness': 'newhotness',
|
|
}
|
|
self.os_release.return_value = 'icehouse'
|
|
for nwmanager in icehouse_cases:
|
|
self.config.return_value = nwmanager
|
|
renamed_manager = neutron.network_manager()
|
|
self.assertEquals(renamed_manager, icehouse_cases[nwmanager])
|
|
|
|
def test_parse_bridge_mappings(self):
|
|
ret = neutron.parse_bridge_mappings(None)
|
|
self.assertEqual(ret, {})
|
|
ret = neutron.parse_bridge_mappings("physnet1:br0")
|
|
self.assertEqual(ret, {'physnet1': 'br0'})
|
|
ret = neutron.parse_bridge_mappings("physnet1:br0 physnet2:br1")
|
|
self.assertEqual(ret, {'physnet1': 'br0', 'physnet2': 'br1'})
|
|
|
|
def test_parse_data_port_mappings(self):
|
|
ret = neutron.parse_data_port_mappings(None)
|
|
self.assertEqual(ret, {})
|
|
ret = neutron.parse_data_port_mappings('br0:eth0')
|
|
self.assertEqual(ret, {'eth0': 'br0'})
|
|
# Back-compat test
|
|
ret = neutron.parse_data_port_mappings('eth0', default_bridge='br0')
|
|
self.assertEqual(ret, {'eth0': 'br0'})
|
|
# Multiple mappings
|
|
ret = neutron.parse_data_port_mappings('br0:eth0 br1:eth1')
|
|
self.assertEqual(ret, {'eth0': 'br0', 'eth1': 'br1'})
|
|
# MultMAC mappings
|
|
ret = neutron.parse_data_port_mappings('br0:cb:23:ae:72:f2:33 '
|
|
'br0:fa:16:3e:12:97:8e')
|
|
self.assertEqual(ret, {'cb:23:ae:72:f2:33': 'br0',
|
|
'fa:16:3e:12:97:8e': 'br0'})
|
|
|
|
def test_parse_vlan_range_mappings(self):
|
|
ret = neutron.parse_vlan_range_mappings(None)
|
|
self.assertEqual(ret, {})
|
|
ret = neutron.parse_vlan_range_mappings('physnet1:1001:2000')
|
|
self.assertEqual(ret, {'physnet1': ('1001', '2000')})
|
|
ret = neutron.parse_vlan_range_mappings('physnet1:1001:2000 physnet2:2001:3000')
|
|
self.assertEqual(ret, {'physnet1': ('1001', '2000'),
|
|
'physnet2': ('2001', '3000')})
|
|
ret = neutron.parse_vlan_range_mappings('physnet1 physnet2:2001:3000')
|
|
self.assertEqual(ret, {'physnet1': ('',),
|
|
'physnet2': ('2001', '3000')})
|