From bf11f609d04535f2acfe6690dbc6e3c4594f936c Mon Sep 17 00:00:00 2001 From: Ryota MIBU Date: Fri, 5 Jul 2013 16:03:59 +0900 Subject: [PATCH] Refactor unit tests for NEC Plugin blueprint nec-plugin-test-coverage This commit refactors the base class of unit tests for NEC Plugin to make writing new tests easier. Add fake OFC Manager and change unit tests which use OFC Manager mock to using this fake. With this fake, we don't need to set return_value and side_effect to the mock instance of OFC Manager in each test case. This fake keeps all resources on OFC, and returns existence of resources properly. This fake is attached to OFC Manager mock instance by setting all side_effects. We can also set it to raise an exception. Make NEC Plugin configurable in each test case. Now we can configure NEC Plugin by setting string in class value "_nec_ini" which will be written into a temporal file and loaded by NEC plugin. Move setup for callbacks into NecPluginV2TestCase() so that other unit tests can use callbacks. Change-Id: I3a52423bb5813547345677dc49abfea6563dd6cd --- neutron/plugins/nec/nec_plugin.py | 3 +- neutron/tests/unit/nec/fake_ofc_manager.py | 106 +++++++++++ neutron/tests/unit/nec/test_nec_plugin.py | 169 +++++++++--------- neutron/tests/unit/nec/test_security_group.py | 6 +- 4 files changed, 190 insertions(+), 94 deletions(-) create mode 100644 neutron/tests/unit/nec/fake_ofc_manager.py diff --git a/neutron/plugins/nec/nec_plugin.py b/neutron/plugins/nec/nec_plugin.py index 144f6da67..d0acc6ebd 100644 --- a/neutron/plugins/nec/nec_plugin.py +++ b/neutron/plugins/nec/nec_plugin.py @@ -124,9 +124,8 @@ class NECPluginV2(nec_plugin_base.NECPluginV2Base, self.l3_agent_notifier = l3_rpc_agent_api.L3AgentNotify # NOTE: callback_sg is referred to from the sg unit test. - self.callback_nec = NECPluginV2RPCCallbacks(self) self.callback_sg = SecurityGroupServerRpcCallback() - callbacks = [self.callback_nec, + callbacks = [NECPluginV2RPCCallbacks(self), DhcpRpcCallback(), L3RpcCallback(), self.callback_sg, agents_db.AgentExtRpcCallback()] diff --git a/neutron/tests/unit/nec/fake_ofc_manager.py b/neutron/tests/unit/nec/fake_ofc_manager.py new file mode 100644 index 000000000..d64b11d03 --- /dev/null +++ b/neutron/tests/unit/nec/fake_ofc_manager.py @@ -0,0 +1,106 @@ +# Copyright (c) 2013 OpenStack Foundation. +# +# Licensed 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. + +import mock + + +OFC_MANAGER = 'neutron.plugins.nec.nec_plugin.ofc_manager.OFCManager' + + +def patch_ofc_manager(): + m = mock.patch(OFC_MANAGER).start() + f = FakeOFCManager() + + m.create_ofc_tenant.side_effect = f.create_ofc_tenant + m.delete_ofc_tenant.side_effect = f.delete_ofc_tenant + m.exists_ofc_tenant.side_effect = f.exists_ofc_tenant + m.create_ofc_network.side_effect = f.create_ofc_net + m.delete_ofc_network.side_effect = f.delete_ofc_net + m.exists_ofc_network.side_effect = f.exists_ofc_net + m.create_ofc_port.side_effect = f.create_ofc_port + m.delete_ofc_port.side_effect = f.delete_ofc_port + m.exists_ofc_port.side_effect = f.exists_ofc_port + m.create_ofc_packet_filter.side_effect = f.create_ofc_pf + m.delete_ofc_packet_filter.side_effect = f.delete_ofc_pf + m.exists_ofc_packet_filter.side_effect = f.exists_ofc_pf + m.set_raise_exc = f.set_raise_exc + + return m + + +class FakeOFCManager(object): + + def __init__(self): + self.ofc_tenants = {} + self.ofc_nets = {} + self.ofc_ports = {} + self.ofc_pfs = {} + self.raise_exc_map = {} + + def set_raise_exc(self, func, raise_exc): + self.raise_exc_map.update({func: raise_exc}) + + def _raise_exc(self, func): + exc = self.raise_exc_map.get(func) + if exc: + raise exc + + def create_ofc_tenant(self, context, tenant_id): + self._raise_exc('create_ofc_tenant') + self.ofc_tenants.update({tenant_id: True}) + + def exists_ofc_tenant(self, context, tenant_id): + self._raise_exc('exists_ofc_tenant') + return self.ofc_tenants.get(tenant_id, False) + + def delete_ofc_tenant(self, context, tenant_id): + self._raise_exc('delete_ofc_tenant') + del self.ofc_tenants[tenant_id] + + def create_ofc_net(self, context, tenant_id, net_id, net_name=None): + self._raise_exc('create_ofc_network') + self.ofc_nets.update({net_id: True}) + + def exists_ofc_net(self, context, net_id): + self._raise_exc('exists_ofc_network') + return self.ofc_nets.get(net_id, False) + + def delete_ofc_net(self, context, net_id, net): + self._raise_exc('delete_ofc_network') + del self.ofc_nets[net_id] + + def create_ofc_port(self, context, port_id, port): + self._raise_exc('create_ofc_port') + self.ofc_ports.update({port_id: True}) + + def exists_ofc_port(self, context, port_id): + self._raise_exc('exists_ofc_port') + return self.ofc_ports.get(port_id, False) + + def delete_ofc_port(self, context, port_id, port): + self._raise_exc('delete_ofc_port') + del self.ofc_ports[port_id] + + def create_ofc_pf(self, context, pf_id, pf_dict): + self._raise_exc('create_ofc_packet_filter') + self.ofc_pfs.update({pf_id: True}) + + def exists_ofc_pf(self, context, pf_id): + self._raise_exc('exists_ofc_packet_filter') + return self.ofc_pfs.get(pf_id, False) + + def delete_ofc_pf(self, context, pf_id): + self._raise_exc('delete_ofc_packet_filter') + del self.ofc_pfs[pf_id] diff --git a/neutron/tests/unit/nec/test_nec_plugin.py b/neutron/tests/unit/nec/test_nec_plugin.py index 5ed8c613b..c9cd5ee52 100644 --- a/neutron/tests/unit/nec/test_nec_plugin.py +++ b/neutron/tests/unit/nec/test_nec_plugin.py @@ -13,38 +13,81 @@ # See the License for the specific language governing permissions and # limitations under the License. +import os + +import fixtures import mock +from neutron.common.test_lib import test_config from neutron.common import topics -from neutron import context as q_context +from neutron import context from neutron.extensions import portbindings from neutron import manager from neutron.plugins.nec.common import exceptions as nexc from neutron.plugins.nec.db import api as ndb from neutron.plugins.nec import nec_plugin from neutron.tests.unit import _test_extension_portbindings as test_bindings +from neutron.tests.unit.nec import fake_ofc_manager from neutron.tests.unit import test_db_plugin as test_plugin from neutron.tests.unit import test_security_groups_rpc as test_sg_rpc PLUGIN_NAME = 'neutron.plugins.nec.nec_plugin.NECPluginV2' -OFC_MANAGER = 'neutron.plugins.nec.nec_plugin.ofc_manager.OFCManager' -OFC_DRIVER = 'neutron.tests.unit.nec.stub_ofc_driver.StubOFCDriver' +NEC_PLUGIN_INI = """ +[DEFAULT] +api_extensions_path = neutron/plugins/nec/extensions +[OFC] +driver = neutron.tests.unit.nec.stub_ofc_driver.StubOFCDriver +enable_packet_filter = False +""" class NecPluginV2TestCase(test_plugin.NeutronDbPluginV2TestCase): _plugin_name = PLUGIN_NAME - PACKET_FILTER_ENABLE = False + _nec_ini = NEC_PLUGIN_INI + + def _set_nec_ini(self): + self.nec_ini_file = self.useFixture(fixtures.TempDir()).join("nec.ini") + with open(self.nec_ini_file, 'w') as f: + f.write(self._nec_ini) + if 'config_files' in test_config.keys(): + for c in test_config['config_files']: + if c.rfind("/nec.ini") > -1: + test_config['config_files'].remove(c) + test_config['config_files'].append(self.nec_ini_file) + else: + test_config['config_files'] = [self.nec_ini_file] + + def _clean_nec_ini(self): + test_config['config_files'].remove(self.nec_ini_file) + os.remove(self.nec_ini_file) + self.nec_ini_file = None + + def rpcapi_update_ports(self, agent_id='nec-q-agent.fake', + datapath_id="0xabc", added=[], removed=[]): + kwargs = {'topic': topics.AGENT, + 'agent_id': agent_id, + 'datapath_id': datapath_id, + 'port_added': added, 'port_removed': removed} + self.callback_nec.update_ports(self.context, **kwargs) def setUp(self): self.addCleanup(mock.patch.stopall) - ofc_manager_cls = mock.patch(OFC_MANAGER).start() - ofc_driver = ofc_manager_cls.return_value.driver - ofc_driver.filter_supported.return_value = self.PACKET_FILTER_ENABLE + + self._set_nec_ini() super(NecPluginV2TestCase, self).setUp(self._plugin_name) - self.context = q_context.get_admin_context() + # NOTE: `test_config' is global, and most tests don't set + # test_config['config_files'] but read this in setUp(). + # So clean test_config['config_files'] ASAP, to avoid side effects + # on other tests which are running at the same time. + self._clean_nec_ini() + self.plugin = manager.NeutronManager.get_plugin() + self.plugin.ofc = fake_ofc_manager.patch_ofc_manager() + self.ofc = self.plugin.ofc + self.callback_nec = nec_plugin.NECPluginV2RPCCallbacks(self.plugin) + self.context = context.get_admin_context() class TestNecBasicGet(test_plugin.TestBasicGet, NecPluginV2TestCase): @@ -84,36 +127,6 @@ class TestNecPortBindingNoSG(TestNecPortBinding): class TestNecPortsV2Callback(NecPluginV2TestCase): - def setUp(self): - super(TestNecPortsV2Callback, self).setUp() - self.callbacks = nec_plugin.NECPluginV2RPCCallbacks(self.plugin) - - self.ofc = self.plugin.ofc - self.ofc_port_exists = False - self._setup_side_effects() - - def _setup_side_effects(self): - def _create_ofc_port_called(*args, **kwargs): - self.ofc_port_exists = True - - def _delete_ofc_port_called(*args, **kwargs): - self.ofc_port_exists = False - - def _exists_ofc_port_called(*args, **kwargs): - return self.ofc_port_exists - - self.ofc.create_ofc_port.side_effect = _create_ofc_port_called - self.ofc.delete_ofc_port.side_effect = _delete_ofc_port_called - self.ofc.exists_ofc_port.side_effect = _exists_ofc_port_called - - def _rpcapi_update_ports(self, agent_id='nec-q-agent.fake', - datapath_id="0xabc", added=[], removed=[]): - kwargs = {'topic': topics.AGENT, - 'agent_id': agent_id, - 'datapath_id': datapath_id, - 'port_added': added, 'port_removed': removed} - self.callbacks.update_ports(self.context, **kwargs) - def _get_portinfo(self, port_id): return ndb.get_portinfo(self.context.session, port_id) @@ -126,7 +139,7 @@ class TestNecPortsV2Callback(NecPluginV2TestCase): self.assertIsNone(self._get_portinfo(port_id)) portinfo = {'id': port_id, 'port_no': 123} - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) sport = self.plugin.get_port(self.context, port_id) self.assertEqual(sport['status'], 'ACTIVE') @@ -152,14 +165,14 @@ class TestNecPortsV2Callback(NecPluginV2TestCase): self.assertEqual(self.ofc.create_ofc_port.call_count, 0) self.assertIsNone(self._get_portinfo(port_id)) - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) self.assertEqual(self.ofc.create_ofc_port.call_count, 1) self.assertEqual(self.ofc.delete_ofc_port.call_count, 0) self.assertIsNotNone(self._get_portinfo(port_id)) # Before port-deletion, switch port removed message is sent. if portinfo_delete_first: - self._rpcapi_update_ports(removed=[port_id]) + self.rpcapi_update_ports(removed=[port_id]) self.assertEqual(self.ofc.delete_ofc_port.call_count, 1) self.assertIsNone(self._get_portinfo(port_id)) @@ -167,7 +180,7 @@ class TestNecPortsV2Callback(NecPluginV2TestCase): if not portinfo_delete_first: self.assertEqual(self.ofc.delete_ofc_port.call_count, 1) self.assertIsNotNone(self._get_portinfo(port_id)) - self._rpcapi_update_ports(removed=[port_id]) + self.rpcapi_update_ports(removed=[port_id]) # Ensure port deletion is called once. self.assertEqual(self.ofc.delete_ofc_port.call_count, 1) @@ -183,7 +196,7 @@ class TestNecPortsV2Callback(NecPluginV2TestCase): def test_portinfo_added_unknown_port(self): portinfo = {'id': 'dummy-p1', 'port_no': 123} - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) self.assertIsNotNone(ndb.get_portinfo(self.context.session, 'dummy-p1')) self.assertEqual(self.ofc.exists_ofc_port.call_count, 0) @@ -195,7 +208,7 @@ class TestNecPortsV2Callback(NecPluginV2TestCase): self.assertEqual(self.ofc.create_ofc_port.call_count, 0) portinfo = {'id': port_id, 'port_no': 123} - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) self.assertEqual(self.ofc.create_ofc_port.call_count, 1) self.assertEqual(self.ofc.delete_ofc_port.call_count, 0) self.assertEqual(ndb.get_portinfo(self.context.session, @@ -203,7 +216,7 @@ class TestNecPortsV2Callback(NecPluginV2TestCase): if portinfo_change_first: portinfo = {'id': port_id, 'port_no': 456} - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) # OFC port is recreated. self.assertEqual(self.ofc.create_ofc_port.call_count, 2) self.assertEqual(self.ofc.delete_ofc_port.call_count, 1) @@ -216,7 +229,7 @@ class TestNecPortsV2Callback(NecPluginV2TestCase): self.assertEqual(self.ofc.delete_ofc_port.call_count, 1) portinfo = {'id': port_id, 'port_no': 456} - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) # No OFC operations are expected. self.assertEqual(self.ofc.create_ofc_port.call_count, 1) self.assertEqual(self.ofc.delete_ofc_port.call_count, 1) @@ -239,22 +252,22 @@ class TestNecPortsV2Callback(NecPluginV2TestCase): self.assertEqual(sport['status'], 'DOWN') portinfo_a = {'id': port_id, 'port_no': port_no_a} - self._rpcapi_update_ports(agent_id=agent_id_a, - datapath_id=datapath_id_a, - added=[portinfo_a]) + self.rpcapi_update_ports(agent_id=agent_id_a, + datapath_id=datapath_id_a, + added=[portinfo_a]) portinfo_b = {'id': port_id, 'port_no': port_no_b} - self._rpcapi_update_ports(agent_id=agent_id_b, - datapath_id=datapath_id_b, - added=[portinfo_b]) + self.rpcapi_update_ports(agent_id=agent_id_b, + datapath_id=datapath_id_b, + added=[portinfo_b]) - self._rpcapi_update_ports(agent_id=agent_id_a, - datapath_id=datapath_id_a, - removed=[port_id]) + self.rpcapi_update_ports(agent_id=agent_id_a, + datapath_id=datapath_id_a, + removed=[port_id]) sport = self.plugin.get_port(self.context, port_id) self.assertEqual(sport['status'], 'ACTIVE') - self.assertTrue(self.ofc_port_exists) + self.assertTrue(self.ofc.ofc_ports[port_id]) expected = [ mock.call.exists_ofc_port(mock.ANY, port_id), @@ -321,7 +334,6 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): return res.status_int def test_create_network(self): - self.ofc.exists_ofc_tenant.return_value = False net = None ctx = mock.ANY with self.network() as network: @@ -339,7 +351,6 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): self.ofc.assert_has_calls(expected) def test_create_network_with_admin_state_down(self): - self.ofc.exists_ofc_tenant.return_value = False net = None ctx = mock.ANY with self.network(admin_state_up=False) as network: @@ -356,7 +367,6 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): self.ofc.assert_has_calls(expected) def test_create_two_network(self): - self.ofc.exists_ofc_tenant.side_effect = [False, True] nets = [] ctx = mock.ANY with self.network() as net1: @@ -381,28 +391,29 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): self.ofc.assert_has_calls(expected) def test_create_network_fail(self): - self.ofc.exists_ofc_tenant.return_value = False self.ofc.create_ofc_network.side_effect = nexc.OFCException( reason='hoge') net = None ctx = mock.ANY - with self.network() as network: + # NOTE: We don't delete network through api, but db will be cleaned in + # tearDown(). When OFCManager has failed to create a network on OFC, + # it does not keeps ofc_network entry and will fail to delete this + # network from OFC. Deletion of network is not the scope of this test. + with self.network(do_delete=False) as network: net = network['network'] + net_ref = self._show('networks', net['id']) + self.assertEqual(net_ref['network']['status'], 'ERROR') expected = [ mock.call.exists_ofc_tenant(ctx, self._tenant_id), mock.call.create_ofc_tenant(ctx, self._tenant_id), mock.call.create_ofc_network(ctx, self._tenant_id, net['id'], - net['name']), - mock.call.delete_ofc_network(ctx, net['id'], mock.ANY), - mock.call.delete_ofc_tenant(ctx, self._tenant_id) + net['name']) ] self.ofc.assert_has_calls(expected) def test_update_network(self): - self.ofc.exists_ofc_tenant.return_value = False - net = None ctx = mock.ANY with self.network() as network: @@ -429,18 +440,7 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): ] self.ofc.assert_has_calls(expected) - def _rpcapi_update_ports(self, agent_id='nec-q-agent.fake', - datapath_id="0xabc", added=[], removed=[]): - kwargs = {'topic': topics.AGENT, - 'agent_id': agent_id, - 'datapath_id': datapath_id, - 'port_added': added, 'port_removed': removed} - self.plugin.callback_nec.update_ports(self.context, **kwargs) - def test_create_port_no_ofc_creation(self): - self.ofc.exists_ofc_tenant.return_value = False - self.ofc.exists_ofc_port.return_value = False - net = None p1 = None ctx = mock.ANY @@ -465,9 +465,6 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): self.ofc.assert_has_calls(expected) def test_create_port_with_ofc_creation(self): - self.ofc.exists_ofc_tenant.return_value = False - self.ofc.exists_ofc_port.side_effect = [False, True] - net = None p1 = None ctx = mock.ANY @@ -484,7 +481,7 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): # Register portinfo, then the port is created on OFC portinfo = {'id': p1['id'], 'port_no': 123} - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) self.assertEqual(self.ofc.create_ofc_port.call_count, 1) expected = [ @@ -504,9 +501,6 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): self.ofc.assert_has_calls(expected) def test_delete_network_with_dhcp_port(self): - self.ofc.exists_ofc_tenant.return_value = False - self.ofc.exists_ofc_port.side_effect = [False, True] - ctx = mock.ANY with self.network() as network: with self.subnet(network=network): @@ -518,7 +512,7 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): 'device_id': 'dhcp-port1'}) # Make sure that the port is created on OFC. portinfo = {'id': p['id'], 'port_no': 123} - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) # In a case of dhcp port, the port is deleted automatically # when delete_network. @@ -543,9 +537,6 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): self._test_update_port_with_admin_state(resource='network') def _test_update_port_with_admin_state(self, resource='port'): - self.ofc.exists_ofc_tenant.return_value = False - self.ofc.exists_ofc_port.side_effect = [False, True, False] - net = None p1 = None ctx = mock.ANY @@ -572,7 +563,7 @@ class TestNecPluginOfcManager(NecPluginV2TestCase): # Register portinfo, then the port is created on OFC portinfo = {'id': p1['id'], 'port_no': 123} - self._rpcapi_update_ports(added=[portinfo]) + self.rpcapi_update_ports(added=[portinfo]) self.assertFalse(self.ofc.create_ofc_port.call_count) self._update_resource(resource, res_id, diff --git a/neutron/tests/unit/nec/test_security_group.py b/neutron/tests/unit/nec/test_security_group.py index 5a35e623a..15c06526e 100644 --- a/neutron/tests/unit/nec/test_security_group.py +++ b/neutron/tests/unit/nec/test_security_group.py @@ -28,9 +28,9 @@ from neutron.tests.unit import test_extension_security_group as test_sg from neutron.tests.unit import test_security_groups_rpc as test_sg_rpc PLUGIN_NAME = test_nec_plugin.PLUGIN_NAME -OFC_MANAGER = test_nec_plugin.OFC_MANAGER -AGENT_NAME = ('neutron.plugins.nec.agent.nec_neutron_agent.NECNeutronAgent') -NOTIFIER = ('neutron.plugins.nec.nec_plugin.NECPluginV2AgentNotifierApi') +OFC_MANAGER = 'neutron.plugins.nec.nec_plugin.ofc_manager.OFCManager' +AGENT_NAME = 'neutron.plugins.nec.agent.nec_neutron_agent.NECNeutronAgent' +NOTIFIER = 'neutron.plugins.nec.nec_plugin.NECPluginV2AgentNotifierApi' class NecSecurityGroupsTestCase(test_sg.SecurityGroupDBTestCase):