Coverage for manila/tests/api/v2/test_share_network_subnets.py: 100%
264 statements
« prev ^ index » next coverage.py v7.11.0, created at 2026-02-18 22:19 +0000
1# Copyright 2019 NetApp, 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.
16import copy
17from unittest import mock
19import ddt
20from oslo_config import cfg
21from oslo_db import exception as db_exception
23from manila.api import common
24from manila.api.openstack import api_version_request as api_version
25from manila.api.v2 import share_network_subnets
26from manila.db import api as db_api
27from manila import exception
28from manila import policy
29from manila import test
30from manila.tests.api import fakes
31from manila.tests import db_utils
32from webob import exc
34CONF = cfg.CONF
37fake_az = {
38 'id': 'ae525e12-07e8-4ddc-a2fd-4a89ad4a65ff',
39 'name': 'fake_az_name'
40}
42fake_default_subnet = {
43 'neutron_net_id': 'fake_nn_id',
44 'neutron_subnet_id': 'fake_nsn_id',
45 'availability_zone_id': None
46}
48fake_subnet_with_az = {
49 'neutron_net_id': 'fake_nn_id',
50 'neutron_subnet_id': 'fake_nsn_id',
51 'availability_zone_id': 'fake_az_id'
52}
55@ddt.ddt
56class ShareNetworkSubnetControllerTest(test.TestCase):
57 """Share network subnet api test"""
59 def setUp(self):
60 super(ShareNetworkSubnetControllerTest, self).setUp()
61 self.controller = share_network_subnets.ShareNetworkSubnetController()
62 self.mock_policy_check = self.mock_object(
63 policy, 'check_policy', mock.Mock(return_value=True))
64 self.resource_name = self.controller.resource_name
65 self.mock_az_get = self.mock_object(db_api, 'availability_zone_get',
66 mock.Mock(return_value=fake_az))
67 self.share_network = db_utils.create_share_network(
68 name='fake_network', id='fake_sn_id')
69 self.subnet_metadata = {'fake_key': 'fake_value'}
70 self.subnet = db_utils.create_share_network_subnet(
71 share_network_id=self.share_network['id'],
72 metadata=self.subnet_metadata)
73 self.share_server = db_utils.create_share_server(
74 share_network_subnets=[self.subnet])
75 self.share = db_utils.create_share()
77 def test_share_network_subnet_delete(self):
78 req = fakes.HTTPRequest.blank('/subnets/%s' % self.subnet['id'],
79 version="2.51")
80 context = req.environ['manila.context']
81 self.subnet['share_servers'] = [self.share_server]
83 mock_sns_get = self.mock_object(
84 db_api, 'share_network_subnet_get',
85 mock.Mock(return_value=self.subnet))
86 mock_all_get_all_shares_by_ss = self.mock_object(
87 db_api, 'share_instance_get_all_by_share_server',
88 mock.Mock(return_value=[]))
89 mock_all_ss_are_auto_deletable = self.mock_object(
90 self.controller, '_all_share_servers_are_auto_deletable',
91 mock.Mock(return_value=True))
92 mock_delete_share_server = self.mock_object(
93 self.controller.share_rpcapi, 'delete_share_server')
94 mock_subnet_delete = self.mock_object(db_api,
95 'share_network_subnet_delete')
97 result = self.controller.delete(req, self.share_network['id'],
98 self.subnet['id'])
100 self.assertEqual(202, result.status_int)
101 mock_sns_get.assert_called_once_with(
102 context, self.subnet['id'])
103 mock_all_get_all_shares_by_ss.assert_called_once_with(
104 context, self.subnet['share_servers'][0].id
105 )
106 mock_all_ss_are_auto_deletable.assert_called_once_with(
107 self.subnet)
108 mock_delete_share_server.assert_called_once_with(
109 context, self.subnet['share_servers'][0])
110 mock_subnet_delete.assert_called_once_with(
111 context, self.subnet['id'])
112 policy.check_policy.assert_called_once_with(
113 context, self.resource_name, 'delete')
115 def test_share_network_subnet_delete_network_not_found(self):
116 req = fakes.HTTPRequest.blank('/subnets/%s' % self.subnet['id'],
117 version="2.51")
118 context = req.environ['manila.context']
120 mock_sn_get = self.mock_object(
121 db_api, 'share_network_get',
122 mock.Mock(side_effect=exception.ShareNetworkNotFound(
123 share_network_id=self.share_network['id']
124 )))
126 self.assertRaises(exc.HTTPNotFound,
127 self.controller.delete,
128 req,
129 self.share_network['id'],
130 self.subnet['id'])
131 mock_sn_get.assert_called_once_with(
132 context, self.share_network['id'])
133 self.mock_policy_check.assert_called_once_with(
134 context, self.resource_name, 'delete')
136 def test_share_network_subnet_delete_subnet_not_found(self):
137 req = fakes.HTTPRequest.blank('/subnets/%s' % self.subnet['id'],
138 version="2.51")
139 context = req.environ['manila.context']
141 mock_sns_get = self.mock_object(
142 db_api, 'share_network_subnet_get',
143 mock.Mock(side_effect=exception.ShareNetworkSubnetNotFound(
144 share_network_subnet_id=self.subnet['id']
145 )))
147 self.assertRaises(exc.HTTPNotFound,
148 self.controller.delete,
149 req,
150 self.share_network['id'],
151 self.subnet['id'])
152 mock_sns_get.assert_called_once_with(
153 context, self.subnet['id'])
154 self.mock_policy_check.assert_called_once_with(
155 context, self.resource_name, 'delete')
157 def test_delete_subnet_with_share_servers_fail(self):
158 req = fakes.HTTPRequest.blank('/subnets/%s' % self.subnet['id'],
159 version="2.51")
160 context = req.environ['manila.context']
161 self.subnet['share_servers'] = [self.share_server]
163 mock_sns_get = self.mock_object(
164 db_api, 'share_network_subnet_get',
165 mock.Mock(return_value=self.subnet))
166 mock_all_get_all_shares_by_ss = self.mock_object(
167 db_api, 'share_instance_get_all_by_share_server',
168 mock.Mock(return_value=[]))
169 mock_all_ss_are_auto_deletable = self.mock_object(
170 self.controller, '_all_share_servers_are_auto_deletable',
171 mock.Mock(return_value=False))
173 self.assertRaises(exc.HTTPConflict,
174 self.controller.delete,
175 req,
176 self.share_network['id'],
177 self.subnet['id'])
179 mock_sns_get.assert_called_once_with(
180 context, self.subnet['id'])
181 mock_all_get_all_shares_by_ss.assert_called_once_with(
182 context, self.subnet['share_servers'][0].id
183 )
184 mock_all_ss_are_auto_deletable.assert_called_once_with(
185 self.subnet
186 )
187 self.mock_policy_check.assert_called_once_with(
188 context, self.resource_name, 'delete')
190 def test_delete_subnet_with_shares_fail(self):
191 req = fakes.HTTPRequest.blank('/subnets/%s' % self.subnet['id'],
192 version="2.51")
193 context = req.environ['manila.context']
194 self.subnet['share_servers'] = [self.share_server]
196 mock_network_get = self.mock_object(
197 db_api, 'share_network_get')
198 mock_sns_get = self.mock_object(
199 db_api, 'share_network_subnet_get',
200 mock.Mock(return_value=self.subnet))
201 mock_all_get_all_shares_by_ss = self.mock_object(
202 db_api, 'share_instance_get_all_by_share_server',
203 mock.Mock(return_value=[self.share]))
205 self.assertRaises(exc.HTTPConflict,
206 self.controller.delete,
207 req,
208 self.share_network['id'],
209 self.subnet['id'])
211 mock_network_get.assert_called_once_with(
212 context, self.share_network['id'])
213 mock_sns_get.assert_called_once_with(
214 context, self.subnet['id'])
215 mock_all_get_all_shares_by_ss.assert_called_once_with(
216 context, self.subnet['share_servers'][0].id
217 )
218 self.mock_policy_check.assert_called_once_with(
219 context, self.resource_name, 'delete')
221 def _setup_create_test_request_body(self, metadata=False):
222 body = {
223 'share_network_id': self.share_network['id'],
224 'availability_zone': fake_az['name'],
225 'neutron_net_id': 'fake_nn_id',
226 'neutron_subnet_id': 'fake_nsn_id'
227 }
228 if metadata:
229 body['metadata'] = self.subnet_metadata
230 return body
232 @ddt.data({'version': "2.51", 'has_share_servers': False},
233 {'version': "2.70", 'has_share_servers': False},
234 {'version': "2.70", 'has_share_servers': True},
235 {'version': "2.78", 'has_share_servers': False})
236 @ddt.unpack
237 def test_subnet_create(self, version, has_share_servers):
238 req = fakes.HTTPRequest.blank('/subnets', version=version)
239 multiple_subnet_support = (req.api_version_request >=
240 api_version.APIVersionRequest("2.70"))
241 metadata_support = (req.api_version_request >=
242 api_version.APIVersionRequest("2.78"))
244 context = req.environ['manila.context']
245 body = {
246 'share-network-subnet': self._setup_create_test_request_body(
247 metadata=metadata_support)
248 }
250 sn_id = body['share-network-subnet']['share_network_id']
251 expected_subnet = copy.deepcopy(self.subnet)
252 if has_share_servers:
253 expected_subnet['share_servers'] = [self.share_server]
255 mock_validate_subnet_create = self.mock_object(
256 common, 'validate_subnet_create',
257 mock.Mock(return_value=(self.share_network, [expected_subnet])))
258 mock_subnet_create = self.mock_object(
259 db_api, 'share_network_subnet_create',
260 mock.Mock(return_value=expected_subnet))
261 mock_update_net_allocations = self.mock_object(
262 self.controller.share_api,
263 'update_share_server_network_allocations',
264 mock.Mock(return_value=expected_subnet))
265 mock_share_network_subnet_get = self.mock_object(
266 db_api, 'share_network_subnet_get',
267 mock.Mock(return_value=expected_subnet))
268 mock_check_metadata_properties = self.mock_object(
269 common, 'check_metadata_properties')
271 fake_data = body['share-network-subnet']
272 fake_data['share_network_id'] = self.share_network['id']
273 res = self.controller.create(
274 req, body['share-network-subnet']['share_network_id'], body)
276 view_subnet = {
277 'id': expected_subnet.get('id'),
278 'availability_zone': expected_subnet.get('availability_zone'),
279 'share_network_id': expected_subnet.get('share_network_id'),
280 'share_network_name': expected_subnet['share_network_name'],
281 'created_at': expected_subnet.get('created_at'),
282 'segmentation_id': expected_subnet.get('segmentation_id'),
283 'neutron_subnet_id': expected_subnet.get('neutron_subnet_id'),
284 'updated_at': expected_subnet.get('updated_at'),
285 'neutron_net_id': expected_subnet.get('neutron_net_id'),
286 'ip_version': expected_subnet.get('ip_version'),
287 'cidr': expected_subnet.get('cidr'),
288 'network_type': expected_subnet.get('network_type'),
289 'mtu': expected_subnet.get('mtu'),
290 'gateway': expected_subnet.get('gateway')
291 }
292 if metadata_support:
293 view_subnet['metadata'] = self.subnet_metadata
294 self.assertEqual(view_subnet, res['share_network_subnet'])
295 mock_share_network_subnet_get.assert_called_once_with(
296 context, expected_subnet['id'])
297 mock_validate_subnet_create.assert_called_once_with(
298 context, sn_id, fake_data, multiple_subnet_support)
299 if has_share_servers:
300 fake_data['share_servers'] = [self.share_server]
301 mock_update_net_allocations.assert_called_once_with(
302 context, self.share_network, fake_data)
303 else:
304 mock_subnet_create.assert_called_once_with(
305 context, fake_data)
306 self.assertEqual(metadata_support,
307 mock_check_metadata_properties.called)
309 @ddt.data({'exception1': exception.ServiceIsDown(service='fake_srv'),
310 'exc_raise': exc.HTTPInternalServerError},
311 {'exception1': exception.InvalidShareNetwork(
312 reason='fake_reason'),
313 'exc_raise': exc.HTTPBadRequest},
314 {'exception1': db_exception.DBError(),
315 'exc_raise': exc.HTTPInternalServerError})
316 @ddt.unpack
317 def test_subnet_create_fail_update_network_allocation(self, exception1,
318 exc_raise):
319 req = fakes.HTTPRequest.blank('/subnets', version="2.70")
320 multiple_subnet_support = (req.api_version_request >=
321 api_version.APIVersionRequest("2.70"))
322 context = req.environ['manila.context']
323 body = {
324 'share-network-subnet': self._setup_create_test_request_body()
325 }
326 sn_id = body['share-network-subnet']['share_network_id']
328 expected_subnet = copy.deepcopy(self.subnet)
329 expected_subnet['share_servers'] = [self.share_server]
331 mock_validate_subnet_create = self.mock_object(
332 common, 'validate_subnet_create',
333 mock.Mock(return_value=(self.share_network, [expected_subnet])))
334 mock_update_net_allocations = self.mock_object(
335 self.controller.share_api,
336 'update_share_server_network_allocations',
337 mock.Mock(side_effect=exception1))
339 fake_data = body['share-network-subnet']
340 fake_data['share_network_id'] = self.share_network['id']
341 fake_data['share_servers'] = [self.share_server]
343 self.assertRaises(exc_raise,
344 self.controller.create,
345 req,
346 body['share-network-subnet']['share_network_id'],
347 body)
349 mock_validate_subnet_create.assert_called_once_with(
350 context, sn_id, fake_data, multiple_subnet_support)
351 mock_update_net_allocations.assert_called_once_with(
352 context, self.share_network, fake_data)
354 def test_subnet_create_invalid_body(self):
355 fake_sn_id = 'fake_id'
356 req = fakes.HTTPRequest.blank('/subnets', version="2.51")
357 body = {}
358 self.assertRaises(exc.HTTPBadRequest,
359 self.controller.create,
360 req,
361 fake_sn_id,
362 body)
364 @ddt.data("2.51", "2.70")
365 def test_subnet_create_subnet_db_error(self, version):
366 req = fakes.HTTPRequest.blank('/subnets', version=version)
367 body = {
368 'share-network-subnet': self._setup_create_test_request_body()
369 }
370 expected_subnet = copy.deepcopy(self.subnet)
371 self.mock_object(
372 common, 'validate_subnet_create',
373 mock.Mock(return_value=(self.share_network, [expected_subnet])))
374 self.mock_object(
375 db_api, 'share_network_subnet_create',
376 mock.Mock(side_effect=db_exception.DBError()))
378 self.assertRaises(exc.HTTPInternalServerError,
379 self.controller.create,
380 req,
381 'fake_sn_id',
382 body)
384 def test_show_subnet(self):
385 subnet = db_utils.create_share_network_subnet(
386 id='fake_sns_2', share_network_id=self.share_network['id'])
387 expected_result = {
388 'share_network_subnet': {
389 "created_at": subnet['created_at'],
390 "id": subnet['id'],
391 "share_network_id": subnet['share_network_id'],
392 "share_network_name": self.share_network['name'],
393 "availability_zone": subnet['availability_zone'],
394 "segmentation_id": subnet['segmentation_id'],
395 "neutron_subnet_id": subnet['neutron_subnet_id'],
396 "updated_at": subnet['updated_at'],
397 "neutron_net_id": subnet['neutron_net_id'],
398 "ip_version": subnet['ip_version'],
399 "cidr": subnet['cidr'],
400 "network_type": subnet['network_type'],
401 "gateway": subnet['gateway'],
402 "mtu": subnet['mtu'],
403 }
404 }
405 req = fakes.HTTPRequest.blank('/subnets/%s' % subnet['id'],
406 version="2.51")
407 context = req.environ['manila.context']
408 mock_sn_get = self.mock_object(
409 db_api, 'share_network_get', mock.Mock(
410 return_value=self.share_network))
411 mock_sns_get = self.mock_object(
412 db_api, 'share_network_subnet_get', mock.Mock(
413 return_value=subnet))
415 result = self.controller.show(req, self.share_network['id'],
416 subnet['id'])
418 self.assertEqual(expected_result, result)
419 mock_sn_get.assert_called_once_with(context, self.share_network['id'])
420 mock_sns_get.assert_called_once_with(context, subnet['id'])
422 @ddt.data(
423 (mock.Mock(side_effect=exception.ShareNetworkNotFound(
424 share_network_id='fake_net_id')), None),
425 (mock.Mock(), mock.Mock(
426 side_effect=exception.ShareNetworkSubnetNotFound(
427 share_network_subnet_id='fake_subnet_id'))))
428 @ddt.unpack
429 def test_show_subnet_not_found(self, sn_get_side_effect,
430 sns_get_side_effect):
431 req = fakes.HTTPRequest.blank('/subnets/%s' % self.subnet['id'],
432 version="2.51")
433 context = req.environ['manila.context']
435 mock_sn_get = self.mock_object(
436 db_api, 'share_network_get', sn_get_side_effect)
437 mock_sns_get = self.mock_object(
438 db_api, 'share_network_subnet_get', sns_get_side_effect)
440 self.assertRaises(exc.HTTPNotFound,
441 self.controller.show,
442 req,
443 self.share_network['id'],
444 self.subnet['id'])
445 mock_sn_get.assert_called_once_with(context, self.share_network['id'])
446 if sns_get_side_effect:
447 mock_sns_get.assert_called_once_with(context, self.subnet['id'])
449 def test_list_subnet(self):
450 share_network_id = 'fake_id'
451 subnet = db_utils.create_share_network_subnet(
452 share_network_id=share_network_id, id='fake_id')
453 fake_sn = db_utils.create_share_network(id=share_network_id)
454 expected_result = {
455 'share_network_subnets': [{
456 "created_at": subnet['created_at'],
457 "id": subnet['id'],
458 "share_network_id": subnet['id'],
459 "share_network_name": fake_sn["name"],
460 "availability_zone": subnet['availability_zone'],
461 "segmentation_id": subnet['segmentation_id'],
462 "neutron_subnet_id": subnet['neutron_subnet_id'],
463 "updated_at": subnet['updated_at'],
464 "neutron_net_id": subnet['neutron_net_id'],
465 "ip_version": subnet['ip_version'],
466 "cidr": subnet['cidr'],
467 "network_type": subnet['network_type'],
468 "gateway": subnet['gateway'],
469 "mtu": subnet['mtu'],
470 }]
471 }
473 req = fakes.HTTPRequest.blank('/subnets/', version="2.51")
474 context = req.environ['manila.context']
475 mock_sn_get = self.mock_object(
476 db_api, 'share_network_get', mock.Mock(
477 return_value=fake_sn))
479 result = self.controller.index(req, self.share_network['id'])
481 self.assertEqual(expected_result, result)
482 mock_sn_get.assert_called_once_with(context, self.share_network['id'])
484 def test_list_subnet_share_network_not_found(self):
485 req = fakes.HTTPRequest.blank('/subnets/', version="2.51")
486 context = req.environ['manila.context']
488 mock_sn_get = self.mock_object(
489 db_api, 'share_network_get', mock.Mock(
490 side_effect=exception.ShareNetworkNotFound(
491 share_network_id=self.share_network['id'])))
493 self.assertRaises(exc.HTTPNotFound,
494 self.controller.index,
495 req,
496 self.share_network['id'])
497 mock_sn_get.assert_called_once_with(context, self.share_network['id'])
499 def test_index_metadata(self):
500 req = fakes.HTTPRequest.blank('/subnets/', version="2.78")
501 mock_index = self.mock_object(
502 self.controller, '_index_metadata',
503 mock.Mock(return_value='fake_metadata'))
505 result = self.controller.index_metadata(req, self.share_network['id'],
506 self.subnet['id'])
508 self.assertEqual('fake_metadata', result)
509 mock_index.assert_called_once_with(req, self.subnet['id'],
510 parent_id=self.share_network['id'])
512 @ddt.data("2.78", "2.89")
513 def test_create_metadata(self, version):
514 req = fakes.HTTPRequest.blank('/subnets/', version=version)
515 context = req.environ['manila.context']
516 mock_index = self.mock_object(
517 self.controller, '_create_metadata',
518 mock.Mock(return_value={'metadata': 'fake_metadata'}))
519 mock_update = self.mock_object(
520 self.controller.share_api,
521 'update_share_network_subnet_from_metadata')
523 body = 'fake_metadata_body'
524 result = self.controller.create_metadata(req, self.share_network['id'],
525 self.subnet['id'], body)
527 self.assertEqual('fake_metadata', result['metadata'])
528 mock_index.assert_called_once_with(req, self.subnet['id'], body,
529 parent_id=self.share_network['id'])
530 metadata_support = (req.api_version_request >=
531 api_version.APIVersionRequest("2.89"))
532 if metadata_support:
533 mock_update.assert_called_once_with(
534 context, self.share_network['id'],
535 self.subnet['id'], 'fake_metadata')
536 else:
537 mock_update.assert_not_called()
539 @ddt.data("2.78", "2.89")
540 def test_update_all_metadata(self, version):
541 req = fakes.HTTPRequest.blank('/subnets/', version=version)
542 context = req.environ['manila.context']
543 mock_index = self.mock_object(
544 self.controller, '_update_all_metadata',
545 mock.Mock(return_value={'metadata': 'fake_metadata'}))
546 mock_update = self.mock_object(
547 self.controller.share_api,
548 'update_share_network_subnet_from_metadata')
550 body = 'fake_metadata_body'
551 result = self.controller.update_all_metadata(
552 req, self.share_network['id'], self.subnet['id'], body)
554 self.assertEqual('fake_metadata', result['metadata'])
555 mock_index.assert_called_once_with(req, self.subnet['id'], body,
556 parent_id=self.share_network['id'])
557 metadata_support = (req.api_version_request >=
558 api_version.APIVersionRequest("2.89"))
559 if metadata_support:
560 mock_update.assert_called_once_with(
561 context, self.share_network['id'],
562 self.subnet['id'], 'fake_metadata')
563 else:
564 mock_update.assert_not_called()
566 @ddt.data("2.78", "2.89")
567 def test_update_metadata_item(self, version):
568 req = fakes.HTTPRequest.blank('/subnets/', version=version)
569 context = req.environ['manila.context']
570 mock_index = self.mock_object(
571 self.controller, '_update_metadata_item',
572 mock.Mock(return_value={'metadata': 'fake_metadata'}))
573 mock_update = self.mock_object(
574 self.controller.share_api,
575 'update_share_network_subnet_from_metadata')
577 body = 'fake_metadata_body'
578 key = 'fake_key'
579 result = self.controller.update_metadata_item(
580 req, self.share_network['id'], self.subnet['id'], body, key)
582 self.assertEqual('fake_metadata', result['metadata'])
583 mock_index.assert_called_once_with(req, self.subnet['id'], body, key,
584 parent_id=self.share_network['id'])
585 metadata_support = (req.api_version_request >=
586 api_version.APIVersionRequest("2.89"))
587 if metadata_support:
588 mock_update.assert_called_once_with(
589 context, self.share_network['id'],
590 self.subnet['id'], 'fake_metadata')
591 else:
592 mock_update.assert_not_called()
594 def test_show_metadata(self):
595 req = fakes.HTTPRequest.blank('/subnets/', version="2.78")
596 mock_index = self.mock_object(
597 self.controller, '_show_metadata',
598 mock.Mock(return_value='fake_metadata'))
600 key = 'fake_key'
601 result = self.controller.show_metadata(
602 req, self.share_network['id'], self.subnet['id'], key)
604 self.assertEqual('fake_metadata', result)
605 mock_index.assert_called_once_with(req, self.subnet['id'], key,
606 parent_id=self.share_network['id'])
608 @ddt.data("2.78", "2.89")
609 def test_delete_metadata(self, version):
610 req = fakes.HTTPRequest.blank('/subnets/', version=version)
611 context = req.environ['manila.context']
612 mock_index = self.mock_object(
613 self.controller, '_delete_metadata',
614 mock.Mock(return_value='fake_metadata'))
615 mock_sn_get = self.mock_object(
616 db_api, 'share_network_get', mock.Mock(
617 return_value=self.share_network))
619 key = 'fake_key'
620 CONF.set_default(
621 "driver_updatable_subnet_metadata", ['fake_key', 'fake_key2'])
623 result = self.controller.delete_metadata(
624 req, self.share_network['id'], self.subnet['id'], key)
626 self.assertEqual('fake_metadata', result)
627 mock_index.assert_called_once_with(req, self.subnet['id'], key,
628 parent_id=self.share_network['id'])
630 metadata_support = (req.api_version_request >=
631 api_version.APIVersionRequest("2.89"))
632 if metadata_support:
633 mock_sn_get.assert_called_once_with(
634 context, self.share_network['id'])
635 else:
636 mock_sn_get.assert_not_called()