Debian Codegraph @

neutron_vpnaas/tests/unit/services/vpn/test_plugin.py

raw
1 # Copyright 2013, Nachi Ueno, NTT I3, Inc.
2 # All Rights Reserved.
3 #
4 # Licensed under the Apache License, Version 2.0 (the "License"); you may
5 # not use this file except in compliance with the License. You may obtain
6 # a copy of the License at
7 #
8 # http://www.apache.org/licenses/LICENSE-2.0
9 #
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 # License for the specific language governing permissions and limitations
14 # under the License.
15 import contextlib
16 from unittest import mock
17
18 from neutron.db import servicetype_db as st_db
19 from neutron.services.flavors import flavors_plugin
20 from neutron.tests.unit.db import test_agentschedulers_db
21 from neutron.tests.unit.extensions import test_agent as test_agent_ext_plugin
22
23 from neutron_lib import constants as lib_constants
24 from neutron_lib import context
25 from neutron_lib import exceptions as lib_exc
26 from neutron_lib.exceptions import flavors as flav_exc
27 from neutron_lib.plugins import constants as p_constants
28 from neutron_lib.plugins import directory
29 from oslo_utils import uuidutils
30
31 from neutron_vpnaas.extensions import vpn_flavors
32 from neutron_vpnaas.services.vpn import plugin as vpn_plugin
33 from neutron_vpnaas.services.vpn.service_drivers import driver_validator
34 from neutron_vpnaas.services.vpn.service_drivers import ipsec as ipsec_driver
35 from neutron_vpnaas.tests import base
36 from neutron_vpnaas.tests.unit.db.vpn import test_vpn_db as test_db_vpnaas
37
38 FAKE_HOST = test_agent_ext_plugin.L3_HOSTA
39 VPN_DRIVER_CLASS = 'neutron_vpnaas.services.vpn.plugin.VPNDriverPlugin'
40
41 IPSEC_SERVICE_DRIVER = ('neutron_vpnaas.services.vpn.service_drivers.'
42 'ipsec.IPsecVPNDriver')
43 DUMMY_IPSEC_SERVICE_DRIVER = ('neutron_vpnaas.tests.unit.dummy_ipsec.'
44 'DummyIPsecVPNDriver')
45
46 _uuid = uuidutils.generate_uuid
47
48
49 class TestVPNDriverPlugin(test_db_vpnaas.TestVpnaas,
50 test_agentschedulers_db.AgentSchedulerTestMixIn,
51 test_agent_ext_plugin.AgentDBTestMixIn):
52
53 def setUp(self):
54 driver_cls_p = mock.patch(
55 'neutron_vpnaas.services.vpn.'
56 'service_drivers.ipsec.IPsecVPNDriver')
57 driver_cls = driver_cls_p.start()
58 self.driver = mock.Mock()
59 self.driver.service_type = ipsec_driver.IPSEC
60 self.driver.validator = driver_validator.VpnDriverValidator(
61 self.driver)
62 driver_cls.return_value = self.driver
63 super().setUp(vpnaas_plugin=VPN_DRIVER_CLASS)
64 # Note: Context must be created after BaseTestCase.setUp() so that
65 # config for policy is set.
66 self.adminContext = context.get_admin_context()
67
68 def test_create_ipsec_site_connection(self, **extras):
69 super().test_create_ipsec_site_connection()
70 self.driver.create_ipsec_site_connection.assert_called_once_with(
71 mock.ANY, mock.ANY)
72 self.driver.delete_ipsec_site_connection.assert_called_once_with(
73 mock.ANY, mock.ANY)
74
75 def test_create_vpnservice(self):
76 mock.patch('neutron_vpnaas.services.vpn.plugin.'
77 'VPNDriverPlugin._get_driver_for_vpnservice',
78 return_value=self.driver).start()
79 stm = directory.get_plugin(p_constants.VPN).service_type_manager
80 stm.add_resource_association = mock.Mock()
81 super().test_create_vpnservice()
82 self.driver.create_vpnservice.assert_called_once_with(
83 mock.ANY, mock.ANY)
84 stm.add_resource_association.assert_called_once_with(
85 mock.ANY, p_constants.VPN, 'vpnaas', mock.ANY)
86
87 def test_delete_vpnservice(self, **extras):
88 stm = directory.get_plugin(p_constants.VPN).service_type_manager
89 stm.del_resource_associations = mock.Mock()
90 super().test_delete_vpnservice()
91 self.driver.delete_vpnservice.assert_called_once_with(
92 mock.ANY, mock.ANY)
93 stm.del_resource_associations.assert_called_once_with(
94 mock.ANY, [mock.ANY])
95
96 def test_update_vpnservice(self, **extras):
97 super().test_update_vpnservice()
98 self.driver.update_vpnservice.assert_called_once_with(
99 mock.ANY, mock.ANY, mock.ANY)
100
101 @contextlib.contextmanager
102 def vpnservice_set(self):
103 """Test case to create a ipsec_site_connection."""
104 vpnservice_name = "vpn1"
105 ipsec_site_connection_name = "ipsec_site_connection"
106 ikename = "ikepolicy1"
107 ipsecname = "ipsecpolicy1"
108 description = "my-vpn-connection"
109 keys = {'name': vpnservice_name,
110 'description': "my-vpn-connection",
111 'peer_address': '192.168.1.10',
112 'peer_id': '192.168.1.10',
113 'peer_cidrs': ['192.168.2.0/24', '192.168.3.0/24'],
114 'initiator': 'bi-directional',
115 'mtu': 1500,
116 'dpd_action': 'hold',
117 'dpd_interval': 40,
118 'dpd_timeout': 120,
119 'tenant_id': self._project_id,
120 'psk': 'abcd',
121 'status': 'PENDING_CREATE',
122 'admin_state_up': True}
123 with self.ikepolicy(name=ikename) as ikepolicy:
124 with self.ipsecpolicy(name=ipsecname) as ipsecpolicy:
125 with self.subnet() as subnet:
126 with self.router() as router:
127 plugin = directory.get_plugin()
128 agent = {'host': FAKE_HOST,
129 'agent_type': lib_constants.AGENT_TYPE_L3,
130 'binary': 'fake-binary',
131 'topic': 'fake-topic'}
132 plugin.create_or_update_agent(self.adminContext, agent)
133 plugin.schedule_router(
134 self.adminContext, router['router']['id'])
135 with self.vpnservice(name=vpnservice_name,
136 subnet=subnet,
137 router=router) as vpnservice1:
138 keys['ikepolicy_id'] = ikepolicy['ikepolicy']['id']
139 keys['ipsecpolicy_id'] = (
140 ipsecpolicy['ipsecpolicy']['id']
141 )
142 keys['vpnservice_id'] = (
143 vpnservice1['vpnservice']['id']
144 )
145 with self.ipsec_site_connection(
146 self.fmt,
147 ipsec_site_connection_name,
148 keys['peer_address'],
149 keys['peer_id'],
150 keys['peer_cidrs'],
151 keys['mtu'],
152 keys['psk'],
153 keys['initiator'],
154 keys['dpd_action'],
155 keys['dpd_interval'],
156 keys['dpd_timeout'],
157 vpnservice1,
158 ikepolicy,
159 ipsecpolicy,
160 keys['admin_state_up'],
161 description=description,
162 ):
163 yield vpnservice1['vpnservice']
164
165 def test_update_status(self):
166 with self.vpnservice_set() as vpnservice:
167 self._register_agent_states()
168 service_plugin = directory.get_plugin(p_constants.VPN)
169 service_plugin.update_status_by_agent(
170 self.adminContext,
171 [{'status': 'ACTIVE',
172 'ipsec_site_connections': {},
173 'updated_pending_status': True,
174 'id': vpnservice['id']}])
175 vpnservice = service_plugin.get_vpnservice(
176 self.adminContext, vpnservice['id'])
177 self.assertEqual(lib_constants.ACTIVE, vpnservice['status'])
178
179
180 class TestVPNDriverPluginMultipleDrivers(base.BaseTestCase):
181
182 def setUp(self):
183 super().setUp()
184 vpnaas_providers = [
185 {'service_type': p_constants.VPN,
186 'name': 'ipsec',
187 'driver': IPSEC_SERVICE_DRIVER,
188 'default': True},
189 {'service_type': p_constants.VPN,
190 'name': 'dummy',
191 'driver': DUMMY_IPSEC_SERVICE_DRIVER,
192 'default': False}]
193 self.service_providers = (
194 mock.patch.object(st_db.ServiceTypeManager,
195 'get_service_providers').start())
196 self.service_providers.return_value = vpnaas_providers
197 self.adminContext = context.get_admin_context()
198
199 @contextlib.contextmanager
200 def vpnservices_providers_set(self, vpnservices=None, provider_names=None):
201 if not vpnservices:
202 vpnservices = []
203 if not provider_names:
204 provider_names = {}
205 stm = st_db.ServiceTypeManager()
206 stm.get_provider_names_by_resource_ids = mock.Mock(
207 return_value=provider_names)
208 mock.patch('neutron.db.servicetype_db.ServiceTypeManager.get_instance',
209 return_value=stm).start()
210 mock.patch('neutron_vpnaas.db.vpn.vpn_db.VPNPluginDb.get_vpnservices',
211 return_value=vpnservices).start()
212 yield stm
213
214 def test_multiple_drivers_loaded(self):
215 with self.vpnservices_providers_set():
216 driver_plugin = vpn_plugin.VPNDriverPlugin()
217 self.assertEqual(2, len(driver_plugin.drivers))
218 self.assertEqual('ipsec', driver_plugin.default_provider)
219 self.assertIn('ipsec', driver_plugin.drivers)
220 self.assertEqual('ipsec', driver_plugin.drivers['ipsec'].name)
221 self.assertIn('dummy', driver_plugin.drivers)
222 self.assertEqual('dummy', driver_plugin.drivers['dummy'].name)
223
224 def test_provider_lost(self):
225 LOST_SERVICE_ID = _uuid()
226 LOST_PROVIDER_SERVICE = {'id': LOST_SERVICE_ID}
227 with self.vpnservices_providers_set(
228 vpnservices=[LOST_PROVIDER_SERVICE],
229 provider_names={LOST_SERVICE_ID: 'LOST_PROVIDER'}
230 ):
231 self.assertRaises(SystemExit, vpn_plugin.VPNDriverPlugin)
232
233 def test_unasso_vpnservices(self):
234 UNASSO_SERVICE_ID = _uuid()
235 with self.vpnservices_providers_set(
236 vpnservices=[{'id': UNASSO_SERVICE_ID}]
237 ) as stm:
238 stm.add_resource_association = mock.Mock()
239 vpn_plugin.VPNDriverPlugin()
240 stm.add_resource_association.assert_called_once_with(
241 mock.ANY, p_constants.VPN, 'ipsec', UNASSO_SERVICE_ID)
242
243 def test_get_driver_for_vpnservice(self):
244 DUMMY_VPNSERVICE_ID = _uuid()
245 DUMMY_VPNSERVICE = {'id': DUMMY_VPNSERVICE_ID}
246 provider_names = {DUMMY_VPNSERVICE_ID: 'dummy'}
247 with self.vpnservices_providers_set(provider_names=provider_names):
248 driver_plugin = vpn_plugin.VPNDriverPlugin()
249 self.assertEqual(
250 driver_plugin.drivers['dummy'],
251 driver_plugin._get_driver_for_vpnservice(
252 self.adminContext, DUMMY_VPNSERVICE))
253
254 def test_get_driver_for_ipsec_site_connection(self):
255 IPSEC_VPNSERVICE_ID = _uuid()
256 IPSEC_SITE_CONNECTION = {'vpnservice_id': IPSEC_VPNSERVICE_ID}
257 provider_names = {IPSEC_VPNSERVICE_ID: 'ipsec'}
258 with self.vpnservices_providers_set(provider_names=provider_names):
259 driver_plugin = vpn_plugin.VPNDriverPlugin()
260 self.assertEqual(
261 driver_plugin.drivers['ipsec'],
262 driver_plugin._get_driver_for_ipsec_site_connection(
263 self.adminContext, IPSEC_SITE_CONNECTION))
264
265 def test_get_provider_for_none_flavor_id(self):
266 with self.vpnservices_providers_set():
267 driver_plugin = vpn_plugin.VPNDriverPlugin()
268 provider = driver_plugin._get_provider_for_flavor(
269 self.adminContext, None)
270 self.assertEqual(
271 driver_plugin.default_provider, provider)
272
273 def test_get_provider_for_flavor_id_plugin_not_loaded(self):
274 with self.vpnservices_providers_set():
275 driver_plugin = vpn_plugin.VPNDriverPlugin()
276 self.assertRaises(
277 vpn_flavors.FlavorsPluginNotLoaded,
278 driver_plugin._get_provider_for_flavor,
279 self.adminContext,
280 _uuid())
281
282 def test_get_provider_for_flavor_id_invalid_type(self):
283 FAKE_FLAVOR = {'service_type': 'NOT_VPN'}
284 directory.add_plugin(p_constants.FLAVORS,
285 flavors_plugin.FlavorsPlugin())
286 mock.patch(
287 'neutron.services.flavors.flavors_plugin.FlavorsPlugin.get_flavor',
288 return_value=FAKE_FLAVOR).start()
289 with self.vpnservices_providers_set():
290 driver_plugin = vpn_plugin.VPNDriverPlugin()
291 self.assertRaises(
292 lib_exc.InvalidServiceType,
293 driver_plugin._get_provider_for_flavor,
294 self.adminContext,
295 _uuid())
296
297 def test_get_provider_for_flavor_id_flavor_disabled(self):
298 FAKE_FLAVOR = {'service_type': p_constants.VPN,
299 'enabled': False}
300 directory.add_plugin(p_constants.FLAVORS,
301 flavors_plugin.FlavorsPlugin())
302 mock.patch(
303 'neutron.services.flavors.flavors_plugin.FlavorsPlugin.get_flavor',
304 return_value=FAKE_FLAVOR).start()
305 with self.vpnservices_providers_set():
306 driver_plugin = vpn_plugin.VPNDriverPlugin()
307 self.assertRaises(
308 flav_exc.FlavorDisabled,
309 driver_plugin._get_provider_for_flavor,
310 self.adminContext,
311 _uuid())
312
313 def test_get_provider_for_flavor_id_provider_not_found(self):
314 FLAVOR_ID = _uuid()
315 FAKE_FLAVOR = {'id': FLAVOR_ID,
316 'service_type': p_constants.VPN,
317 'enabled': True}
318 PROVIDERS = [{'provider': 'SOME_PROVIDER'}]
319 directory.add_plugin(p_constants.FLAVORS,
320 flavors_plugin.FlavorsPlugin())
321 mock.patch(
322 'neutron.services.flavors.flavors_plugin.FlavorsPlugin.get_flavor',
323 return_value=FAKE_FLAVOR).start()
324 mock.patch(
325 'neutron.services.flavors.flavors_plugin.'
326 'FlavorsPlugin.get_flavor_next_provider',
327 return_value=PROVIDERS).start()
328 with self.vpnservices_providers_set():
329 driver_plugin = vpn_plugin.VPNDriverPlugin()
330 self.assertRaises(
331 vpn_flavors.NoProviderFoundForFlavor,
332 driver_plugin._get_provider_for_flavor,
333 self.adminContext,
334 FLAVOR_ID)
335
336 def test_get_provider_for_flavor_id(self):
337 FLAVOR_ID = _uuid()
338 FAKE_FLAVOR = {'id': FLAVOR_ID,
339 'service_type': p_constants.VPN,
340 'enabled': True}
341 PROVIDERS = [{'provider': 'dummy'}]
342 directory.add_plugin(p_constants.FLAVORS,
343 flavors_plugin.FlavorsPlugin())
344 mock.patch(
345 'neutron.services.flavors.flavors_plugin.FlavorsPlugin.get_flavor',
346 return_value=FAKE_FLAVOR).start()
347 mock.patch(
348 'neutron.services.flavors.flavors_plugin.'
349 'FlavorsPlugin.get_flavor_next_provider',
350 return_value=PROVIDERS).start()
351 with self.vpnservices_providers_set():
352 driver_plugin = vpn_plugin.VPNDriverPlugin()
353 self.assertEqual(
354 'dummy',
355 driver_plugin._get_provider_for_flavor(
356 self.adminContext, FLAVOR_ID))