Debian Codegraph @

neutron_vpnaas/tests/unit/extensions/test_vpnaas.py

raw
1 # (c) Copyright 2013 Hewlett-Packard Development Company, L.P.
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
16 import copy
17 from unittest import mock
18
19 from neutron.tests.unit.api.v2 import test_base as test_api_v2
20 from neutron_lib.plugins import constants as nconstants
21 from oslo_utils import uuidutils
22 from webob import exc
23
24 from neutron_vpnaas.extensions import vpnaas
25 from neutron_vpnaas.tests import base
26
27 _uuid = uuidutils.generate_uuid
28 _get_path = test_api_v2._get_path
29
30
31 class VpnaasExtensionTestCase(base.ExtensionTestCase):
32 fmt = 'json'
33
34 def setUp(self):
35 super().setUp()
36 plural_mappings = {'ipsecpolicy': 'ipsecpolicies',
37 'ikepolicy': 'ikepolicies',
38 'ipsec_site_connection': 'ipsec-site-connections',
39 'endpoint_group': 'endpoint-groups'}
40 self.setup_extension(
41 'neutron_vpnaas.extensions.vpnaas.VPNPluginBase', nconstants.VPN,
42 vpnaas.Vpnaas, 'vpn', plural_mappings=plural_mappings,
43 use_quota=True)
44
45 def test_ikepolicy_create(self):
46 """Test case to create an ikepolicy."""
47 ikepolicy_id = _uuid()
48 data = {'ikepolicy': {'name': 'ikepolicy1',
49 'description': 'myikepolicy1',
50 'auth_algorithm': 'sha1',
51 'encryption_algorithm': 'aes-128',
52 'phase1_negotiation_mode': 'main',
53 'lifetime': {
54 'units': 'seconds',
55 'value': 3600},
56 'ike_version': 'v1',
57 'pfs': 'group5',
58 'tenant_id': _uuid()}}
59
60 return_value = copy.copy(data['ikepolicy'])
61 return_value.update({'id': ikepolicy_id})
62
63 instance = self.plugin.return_value
64 instance.create_ikepolicy.return_value = return_value
65 res = self.api.post(_get_path('vpn/ikepolicies', fmt=self.fmt),
66 self.serialize(data),
67 content_type='application/%s' % self.fmt)
68 self.assertEqual(1, instance.create_ikepolicy.call_count)
69 self.assertEqual(exc.HTTPCreated.code, res.status_int)
70 res = self.deserialize(res)
71 self.assertIn('ikepolicy', res)
72 self.assertDictSupersetOf(return_value, res['ikepolicy'])
73
74 def test_ikepolicy_create_with_aggressive_mode(self):
75 """Test case to create an ikepolicy with agressive mode."""
76 ikepolicy_id = _uuid()
77 data = {'ikepolicy': {'name': 'ikepolicy1',
78 'description': 'myikepolicy1',
79 'auth_algorithm': 'sha1',
80 'encryption_algorithm': 'aes-128',
81 'phase1_negotiation_mode': 'aggressive',
82 'lifetime': {
83 'units': 'seconds',
84 'value': 3600},
85 'ike_version': 'v1',
86 'pfs': 'group5',
87 'tenant_id': _uuid()}}
88
89 return_value = copy.copy(data['ikepolicy'])
90 return_value.update({'id': ikepolicy_id})
91
92 instance = self.plugin.return_value
93 instance.create_ikepolicy.return_value = return_value
94 res = self.api.post(_get_path('vpn/ikepolicies', fmt=self.fmt),
95 self.serialize(data),
96 content_type='application/%s' % self.fmt)
97 self.assertEqual(1, instance.create_ikepolicy.call_count)
98 self.assertEqual(exc.HTTPCreated.code, res.status_int)
99 res = self.deserialize(res)
100 self.assertIn('ikepolicy', res)
101 self.assertDictSupersetOf(return_value, res['ikepolicy'])
102
103 def test_ikepolicy_list(self):
104 """Test case to list all ikepolicies."""
105 ikepolicy_id = _uuid()
106 return_value = [{'name': 'ikepolicy1',
107 'auth_algorithm': 'sha1',
108 'encryption_algorithm': 'aes-128',
109 'pfs': 'group5',
110 'ike_version': 'v1',
111 'id': ikepolicy_id}]
112
113 instance = self.plugin.return_value
114 instance.get_ikepolicies.return_value = return_value
115
116 res = self.api.get(_get_path('vpn/ikepolicies', fmt=self.fmt))
117
118 instance.get_ikepolicies.assert_called_with(mock.ANY,
119 fields=mock.ANY,
120 filters=mock.ANY)
121 self.assertEqual(exc.HTTPOk.code, res.status_int)
122
123 def test_ikepolicy_update(self):
124 """Test case to update an ikepolicy."""
125 ikepolicy_id = _uuid()
126 update_data = {'ikepolicy': {'name': 'ikepolicy1',
127 'encryption_algorithm': 'aes-256'}}
128 return_value = {'name': 'ikepolicy1',
129 'auth_algorithm': 'sha1',
130 'encryption_algorithm': 'aes-256',
131 'phase1_negotiation_mode': 'main',
132 'lifetime': {
133 'units': 'seconds',
134 'value': 3600},
135 'ike_version': 'v1',
136 'pfs': 'group5',
137 'tenant_id': _uuid(),
138 'id': ikepolicy_id}
139
140 instance = self.plugin.return_value
141 instance.update_ikepolicy.return_value = return_value
142
143 res = self.api.put(_get_path('vpn/ikepolicies', id=ikepolicy_id,
144 fmt=self.fmt),
145 self.serialize(update_data))
146
147 instance.update_ikepolicy.assert_called_with(mock.ANY, ikepolicy_id,
148 ikepolicy=update_data)
149 self.assertEqual(exc.HTTPOk.code, res.status_int)
150 res = self.deserialize(res)
151 self.assertIn('ikepolicy', res)
152 self.assertEqual(return_value, res['ikepolicy'])
153
154 def test_ikepolicy_update_with_aggressive_mode(self):
155 """Test case to update an ikepolicy with aggressive mode."""
156 ikepolicy_id = _uuid()
157 update_data = {'ikepolicy':
158 {'name': 'ikepolicy1',
159 'phase1_negotiation_mode': 'aggressive',
160 'encryption_algorithm': 'aes-256'}}
161 return_value = {'name': 'ikepolicy1',
162 'auth_algorithm': 'sha1',
163 'encryption_algorithm': 'aes-256',
164 'phase1_negotiation_mode': 'aggressive',
165 'lifetime': {
166 'units': 'seconds',
167 'value': 3600},
168 'ike_version': 'v1',
169 'pfs': 'group5',
170 'tenant_id': _uuid(),
171 'id': ikepolicy_id}
172
173 instance = self.plugin.return_value
174 instance.update_ikepolicy.return_value = return_value
175
176 res = self.api.put(_get_path('vpn/ikepolicies', id=ikepolicy_id,
177 fmt=self.fmt),
178 self.serialize(update_data))
179
180 instance.update_ikepolicy.assert_called_with(mock.ANY, ikepolicy_id,
181 ikepolicy=update_data)
182 self.assertEqual(exc.HTTPOk.code, res.status_int)
183 res = self.deserialize(res)
184 self.assertIn('ikepolicy', res)
185 self.assertEqual(return_value, res['ikepolicy'])
186
187 def test_ikepolicy_get(self):
188 """Test case to get or show an ikepolicy."""
189 ikepolicy_id = _uuid()
190 return_value = {'name': 'ikepolicy1',
191 'auth_algorithm': 'sha1',
192 'encryption_algorithm': 'aes-128',
193 'phase1_negotiation_mode': 'main',
194 'lifetime': {
195 'units': 'seconds',
196 'value': 3600},
197 'ike_version': 'v1',
198 'pfs': 'group5',
199 'tenant_id': _uuid(),
200 'id': ikepolicy_id}
201
202 instance = self.plugin.return_value
203 instance.get_ikepolicy.return_value = return_value
204
205 res = self.api.get(_get_path('vpn/ikepolicies', id=ikepolicy_id,
206 fmt=self.fmt))
207
208 instance.get_ikepolicy.assert_called_with(mock.ANY,
209 ikepolicy_id,
210 fields=mock.ANY)
211 self.assertEqual(exc.HTTPOk.code, res.status_int)
212 res = self.deserialize(res)
213 self.assertIn('ikepolicy', res)
214 self.assertEqual(return_value, res['ikepolicy'])
215
216 def test_ikepolicy_delete(self):
217 """Test case to delete an ikepolicy."""
218 self._test_entity_delete('ikepolicy')
219
220 def test_ipsecpolicy_create(self):
221 """Test case to create an ipsecpolicy."""
222 ipsecpolicy_id = _uuid()
223 data = {'ipsecpolicy': {'name': 'ipsecpolicy1',
224 'description': 'myipsecpolicy1',
225 'auth_algorithm': 'sha1',
226 'encryption_algorithm': 'aes-128',
227 'encapsulation_mode': 'tunnel',
228 'lifetime': {
229 'units': 'seconds',
230 'value': 3600},
231 'transform_protocol': 'esp',
232 'pfs': 'group5',
233 'tenant_id': _uuid()}}
234 return_value = copy.copy(data['ipsecpolicy'])
235 return_value.update({'id': ipsecpolicy_id})
236
237 instance = self.plugin.return_value
238 instance.create_ipsecpolicy.return_value = return_value
239 res = self.api.post(_get_path('vpn/ipsecpolicies', fmt=self.fmt),
240 self.serialize(data),
241 content_type='application/%s' % self.fmt)
242 self.assertEqual(1, instance.create_ipsecpolicy.call_count)
243 self.assertEqual(exc.HTTPCreated.code, res.status_int)
244 res = self.deserialize(res)
245 self.assertIn('ipsecpolicy', res)
246 self.assertDictSupersetOf(return_value, res['ipsecpolicy'])
247
248 def test_ipsecpolicy_list(self):
249 """Test case to list an ipsecpolicy."""
250 ipsecpolicy_id = _uuid()
251 return_value = [{'name': 'ipsecpolicy1',
252 'auth_algorithm': 'sha1',
253 'encryption_algorithm': 'aes-128',
254 'pfs': 'group5',
255 'id': ipsecpolicy_id}]
256
257 instance = self.plugin.return_value
258 instance.get_ipsecpolicies.return_value = return_value
259
260 res = self.api.get(_get_path('vpn/ipsecpolicies', fmt=self.fmt))
261
262 instance.get_ipsecpolicies.assert_called_with(mock.ANY,
263 fields=mock.ANY,
264 filters=mock.ANY)
265 self.assertEqual(exc.HTTPOk.code, res.status_int)
266
267 def test_ipsecpolicy_update(self):
268 """Test case to update an ipsecpolicy."""
269 ipsecpolicy_id = _uuid()
270 update_data = {'ipsecpolicy': {'name': 'ipsecpolicy1',
271 'encryption_algorithm': 'aes-256'}}
272 return_value = {'name': 'ipsecpolicy1',
273 'auth_algorithm': 'sha1',
274 'encryption_algorithm': 'aes-128',
275 'encapsulation_mode': 'tunnel',
276 'lifetime': {
277 'units': 'seconds',
278 'value': 3600},
279 'transform_protocol': 'esp',
280 'pfs': 'group5',
281 'tenant_id': _uuid(),
282 'id': ipsecpolicy_id}
283
284 instance = self.plugin.return_value
285 instance.update_ipsecpolicy.return_value = return_value
286
287 res = self.api.put(_get_path('vpn/ipsecpolicies',
288 id=ipsecpolicy_id,
289 fmt=self.fmt),
290 self.serialize(update_data))
291
292 instance.update_ipsecpolicy.assert_called_with(mock.ANY,
293 ipsecpolicy_id,
294 ipsecpolicy=update_data)
295 self.assertEqual(exc.HTTPOk.code, res.status_int)
296 res = self.deserialize(res)
297 self.assertIn('ipsecpolicy', res)
298 self.assertEqual(return_value, res['ipsecpolicy'])
299
300 def test_ipsecpolicy_get(self):
301 """Test case to get or show an ipsecpolicy."""
302 ipsecpolicy_id = _uuid()
303 return_value = {'name': 'ipsecpolicy1',
304 'auth_algorithm': 'sha1',
305 'encryption_algorithm': 'aes-128',
306 'encapsulation_mode': 'tunnel',
307 'lifetime': {
308 'units': 'seconds',
309 'value': 3600},
310 'transform_protocol': 'esp',
311 'pfs': 'group5',
312 'tenant_id': _uuid(),
313 'id': ipsecpolicy_id}
314
315 instance = self.plugin.return_value
316 instance.get_ipsecpolicy.return_value = return_value
317
318 res = self.api.get(_get_path('vpn/ipsecpolicies',
319 id=ipsecpolicy_id,
320 fmt=self.fmt))
321
322 instance.get_ipsecpolicy.assert_called_with(mock.ANY,
323 ipsecpolicy_id,
324 fields=mock.ANY)
325 self.assertEqual(exc.HTTPOk.code, res.status_int)
326 res = self.deserialize(res)
327 self.assertIn('ipsecpolicy', res)
328 self.assertEqual(return_value, res['ipsecpolicy'])
329
330 def test_ipsecpolicy_delete(self):
331 """Test case to delete an ipsecpolicy."""
332 self._test_entity_delete('ipsecpolicy')
333
334 def _test_vpnservice_create(self, more_args, defaulted_args):
335 """Helper to test VPN service creation.
336
337 Allows additional args to be specified for different test cases.
338 Includes expected args, for case where an optional args are not
339 specified and API applies defaults.
340 """
341
342 data = {'vpnservice': {'name': 'vpnservice1',
343 'description': 'descr_vpn1',
344 'router_id': _uuid(),
345 'admin_state_up': True,
346 'tenant_id': _uuid()}}
347 data['vpnservice'].update(more_args)
348
349 # Add in any default values for args that were not provided
350 actual_args = copy.copy(data)
351 actual_args['vpnservice'].update(defaulted_args)
352
353 return_value = copy.copy(data['vpnservice'])
354 return_value.update({'status': "ACTIVE", 'id': _uuid()})
355 return_value.update(defaulted_args)
356 instance = self.plugin.return_value
357 instance.create_vpnservice.return_value = return_value
358
359 res = self.api.post(_get_path('vpn/vpnservices', fmt=self.fmt),
360 self.serialize(data),
361 content_type='application/%s' % self.fmt)
362 self.assertEqual(1, instance.create_vpnservice.call_count)
363 self.assertEqual(exc.HTTPCreated.code, res.status_int)
364 res = self.deserialize(res)
365 self.assertIn('vpnservice', res)
366 self.assertDictSupersetOf(return_value, res['vpnservice'])
367
368 def test_vpnservice_create(self):
369 """Create VPN service using subnet (older API)."""
370 subnet = {'subnet_id': _uuid()}
371 self._test_vpnservice_create(more_args=subnet, defaulted_args={})
372
373 def test_vpnservice_create_no_subnet(self):
374 """Test case to create a vpnservice w/o subnet (newer API)."""
375 no_subnet = {'subnet_id': None}
376 self._test_vpnservice_create(more_args={}, defaulted_args=no_subnet)
377
378 def test_vpnservice_list(self):
379 """Test case to list all vpnservices."""
380 vpnservice_id = _uuid()
381 return_value = [{'name': 'vpnservice1',
382 'tenant_id': _uuid(),
383 'status': 'ACTIVE',
384 'id': vpnservice_id}]
385
386 instance = self.plugin.return_value
387 instance.get_vpnservice.return_value = return_value
388
389 res = self.api.get(_get_path('vpn/vpnservices', fmt=self.fmt))
390
391 instance.get_vpnservices.assert_called_with(mock.ANY,
392 fields=mock.ANY,
393 filters=mock.ANY)
394 self.assertEqual(exc.HTTPOk.code, res.status_int)
395
396 def test_vpnservice_update(self):
397 """Test case to update a vpnservice."""
398 vpnservice_id = _uuid()
399 update_data = {'vpnservice': {'admin_state_up': False}}
400 return_value = {'name': 'vpnservice1',
401 'admin_state_up': False,
402 'subnet_id': _uuid(),
403 'router_id': _uuid(),
404 'tenant_id': _uuid(),
405 'status': "ACTIVE",
406 'id': vpnservice_id}
407
408 instance = self.plugin.return_value
409 instance.update_vpnservice.return_value = return_value
410
411 res = self.api.put(_get_path('vpn/vpnservices',
412 id=vpnservice_id,
413 fmt=self.fmt),
414 self.serialize(update_data))
415
416 instance.update_vpnservice.assert_called_with(mock.ANY,
417 vpnservice_id,
418 vpnservice=update_data)
419 self.assertEqual(exc.HTTPOk.code, res.status_int)
420 res = self.deserialize(res)
421 self.assertIn('vpnservice', res)
422 self.assertEqual(return_value, res['vpnservice'])
423
424 def test_vpnservice_get(self):
425 """Test case to get or show a vpnservice."""
426 vpnservice_id = _uuid()
427 return_value = {'name': 'vpnservice1',
428 'admin_state_up': True,
429 'subnet_id': _uuid(),
430 'router_id': _uuid(),
431 'tenant_id': _uuid(),
432 'status': "ACTIVE",
433 'id': vpnservice_id}
434
435 instance = self.plugin.return_value
436 instance.get_vpnservice.return_value = return_value
437
438 res = self.api.get(_get_path('vpn/vpnservices',
439 id=vpnservice_id,
440 fmt=self.fmt))
441
442 instance.get_vpnservice.assert_called_with(mock.ANY,
443 vpnservice_id,
444 fields=mock.ANY)
445 self.assertEqual(exc.HTTPOk.code, res.status_int)
446 res = self.deserialize(res)
447 self.assertIn('vpnservice', res)
448 self.assertEqual(return_value, res['vpnservice'])
449
450 def test_vpnservice_delete(self):
451 """Test case to delete a vpnservice."""
452 self._test_entity_delete('vpnservice')
453
454 def _test_ipsec_site_connection_create(self, more_args, defaulted_args):
455 """Helper to test creating IPSec connection."""
456 ipsecsite_con_id = _uuid()
457 ikepolicy_id = _uuid()
458 ipsecpolicy_id = _uuid()
459 data = {
460 'ipsec_site_connection': {'name': 'connection1',
461 'description': 'Remote-connection1',
462 'peer_address': '192.168.1.10',
463 'peer_id': '192.168.1.10',
464 'mtu': 1500,
465 'psk': 'abcd',
466 'initiator': 'bi-directional',
467 'dpd': {
468 'action': 'hold',
469 'interval': 30,
470 'timeout': 120},
471 'ikepolicy_id': ikepolicy_id,
472 'ipsecpolicy_id': ipsecpolicy_id,
473 'vpnservice_id': _uuid(),
474 'admin_state_up': True,
475 'tenant_id': _uuid()}
476 }
477 data['ipsec_site_connection'].update(more_args)
478
479 # Add in any default values for args that were not provided
480 actual_args = copy.copy(data)
481 actual_args['ipsec_site_connection'].update(defaulted_args)
482
483 return_value = copy.copy(data['ipsec_site_connection'])
484 return_value.update({'status': "ACTIVE", 'id': ipsecsite_con_id})
485 return_value.update(defaulted_args)
486 instance = self.plugin.return_value
487 instance.create_ipsec_site_connection.return_value = return_value
488
489 res = self.api.post(_get_path('vpn/ipsec-site-connections',
490 fmt=self.fmt),
491 self.serialize(data),
492 content_type='application/%s' % self.fmt)
493 self.assertEqual(1, instance.create_ipsec_site_connection.call_count)
494 self.assertEqual(exc.HTTPCreated.code, res.status_int)
495 res = self.deserialize(res)
496 self.assertIn('ipsec_site_connection', res)
497 self.assertDictSupersetOf(return_value, res['ipsec_site_connection'])
498
499 def test_ipsec_site_connection_create(self):
500 """Create an IPSec connection with peer CIDRs (old API)."""
501 more_args = {'peer_cidrs': ['192.168.2.0/24', '192.168.3.0/24'],
502 'local_id': ''}
503 no_endpoint_groups = {'local_ep_group_id': None,
504 'peer_ep_group_id': None}
505 self._test_ipsec_site_connection_create(
506 more_args=more_args, defaulted_args=no_endpoint_groups)
507
508 def test_ipsec_site_connection_create_with_endpoints(self):
509 """Create an IPSec connection with endpoint groups (new API)."""
510 more_args = {'local_ep_group_id': _uuid(),
511 'peer_ep_group_id': _uuid(),
512 'local_id': ''}
513 no_peer_cidrs = {'peer_cidrs': []}
514 self._test_ipsec_site_connection_create(more_args=more_args,
515 defaulted_args=no_peer_cidrs)
516
517 def test_ipsec_site_connection_create_with_invalid_cidr_format(self):
518 peer_cidrs = ['192.168.2.0/24', '10/8']
519 data = {
520 'ipsec_site_connection': {'name': 'connection1',
521 'description': 'Remote-connection1',
522 'peer_address': '192.168.1.10',
523 'peer_id': '192.168.1.10',
524 'peer_cidrs': peer_cidrs,
525 'mtu': 1500,
526 'psk': 'abcd',
527 'initiator': 'bi-directional',
528 'dpd': {
529 'action': 'hold',
530 'interval': 30,
531 'timeout': 120},
532 'ikepolicy_id': _uuid(),
533 'ipsecpolicy_id': _uuid(),
534 'vpnservice_id': _uuid(),
535 'admin_state_up': True,
536 'tenant_id': _uuid()}
537 }
538 res = self.api.post(_get_path('vpn/ipsec-site-connections',
539 fmt=self.fmt),
540 self.serialize(data),
541 content_type='application/%s' % self.fmt,
542 expect_errors=True)
543 self.assertEqual(exc.HTTPBadRequest.code, res.status_int)
544
545 def test_ipsec_site_connection_list(self):
546 """Test case to list all ipsec_site_connections."""
547 ipsecsite_con_id = _uuid()
548 return_value = [{'name': 'connection1',
549 'peer_address': '192.168.1.10',
550 'peer_cidrs': ['192.168.2.0/24', '192.168.3.0/24'],
551 'route_mode': 'static',
552 'auth_mode': 'psk',
553 'local_ep_group_id': None,
554 'peer_ep_group_id': None,
555 'tenant_id': _uuid(),
556 'status': 'ACTIVE',
557 'id': ipsecsite_con_id}]
558
559 instance = self.plugin.return_value
560 instance.get_ipsec_site_connections.return_value = return_value
561
562 res = self.api.get(
563 _get_path('vpn/ipsec-site-connections', fmt=self.fmt))
564
565 instance.get_ipsec_site_connections.assert_called_with(
566 mock.ANY, fields=mock.ANY, filters=mock.ANY
567 )
568 self.assertEqual(exc.HTTPOk.code, res.status_int)
569
570 def test_ipsec_site_connection_update(self):
571 """Test case to update a ipsec_site_connection."""
572 ipsecsite_con_id = _uuid()
573 update_data = {'ipsec_site_connection': {'admin_state_up': False}}
574 return_value = {'name': 'connection1',
575 'description': 'Remote-connection1',
576 'peer_address': '192.168.1.10',
577 'peer_id': '192.168.1.10',
578 'peer_cidrs': ['192.168.2.0/24', '192.168.3.0/24'],
579 'mtu': 1500,
580 'psk': 'abcd',
581 'initiator': 'bi-directional',
582 'dpd': {
583 'action': 'hold',
584 'interval': 30,
585 'timeout': 120},
586 'ikepolicy_id': _uuid(),
587 'ipsecpolicy_id': _uuid(),
588 'vpnservice_id': _uuid(),
589 'admin_state_up': False,
590 'local_ep_group_id': None,
591 'peer_ep_group_id': None,
592 'tenant_id': _uuid(),
593 'status': 'ACTIVE',
594 'id': ipsecsite_con_id}
595
596 instance = self.plugin.return_value
597 instance.update_ipsec_site_connection.return_value = return_value
598
599 res = self.api.put(_get_path('vpn/ipsec-site-connections',
600 id=ipsecsite_con_id,
601 fmt=self.fmt),
602 self.serialize(update_data))
603
604 instance.update_ipsec_site_connection.assert_called_with(
605 mock.ANY, ipsecsite_con_id, ipsec_site_connection=update_data
606 )
607
608 self.assertEqual(exc.HTTPOk.code, res.status_int)
609 res = self.deserialize(res)
610 self.assertIn('ipsec_site_connection', res)
611 self.assertEqual(return_value, res['ipsec_site_connection'])
612
613 def test_ipsec_site_connection_get(self):
614 """Test case to get or show a ipsec_site_connection."""
615 ipsecsite_con_id = _uuid()
616 return_value = {'name': 'connection1',
617 'description': 'Remote-connection1',
618 'peer_address': '192.168.1.10',
619 'peer_id': '192.168.1.10',
620 'peer_cidrs': ['192.168.2.0/24',
621 '192.168.3.0/24'],
622 'mtu': 1500,
623 'psk': 'abcd',
624 'initiator': 'bi-directional',
625 'dpd': {
626 'action': 'hold',
627 'interval': 30,
628 'timeout': 120},
629 'ikepolicy_id': _uuid(),
630 'ipsecpolicy_id': _uuid(),
631 'vpnservice_id': _uuid(),
632 'admin_state_up': True,
633 'tenant_id': _uuid(),
634 'local_ep_group_id': None,
635 'peer_ep_group_id': None,
636 'status': 'ACTIVE',
637 'id': ipsecsite_con_id}
638
639 instance = self.plugin.return_value
640 instance.get_ipsec_site_connection.return_value = return_value
641
642 res = self.api.get(_get_path('vpn/ipsec-site-connections',
643 id=ipsecsite_con_id,
644 fmt=self.fmt))
645
646 instance.get_ipsec_site_connection.assert_called_with(
647 mock.ANY, ipsecsite_con_id, fields=mock.ANY
648 )
649 self.assertEqual(exc.HTTPOk.code, res.status_int)
650 res = self.deserialize(res)
651 self.assertIn('ipsec_site_connection', res)
652 self.assertEqual(return_value, res['ipsec_site_connection'])
653
654 def test_ipsec_site_connection_delete(self):
655 """Test case to delete a ipsec_site_connection."""
656 self._test_entity_delete('ipsec_site_connection')