1 # -*- coding: utf-8 -*-
4 # Copyright 2017 Intel Corporation.
6 # Licensed under the Apache License, Version 2.0 (the "License"); you may
7 # not use this file except in compliance with the License. You may obtain
8 # a copy of the License at
10 # http://www.apache.org/licenses/LICENSE-2.0
12 # Unless required by applicable law or agreed to in writing, software
13 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15 # License for the specific language governing permissions and limitations
18 # For those usages not covered by the Apache License, Version 2.0 please
19 # contact with: nfvlabs@tid.es
23 This module contains unit tests for the OpenStack VIM connector
24 Run this directly with python2 or python3.
26 from copy
import deepcopy
30 import cinderclient
.exceptions
as cExceptions
31 from mock
import MagicMock
, patch
32 from neutronclient
.common
import exceptions
as neExceptions
33 from novaclient
import exceptions
as nvExceptions
34 from novaclient
.exceptions
import ClientException
, Conflict
35 from osm_ro_plugin
.vimconn
import (
36 VimConnConnectionException
,
38 VimConnNotFoundException
,
39 VimConnUnexpectedResponse
,
41 from osm_rovim_openstack
.vimconn_openstack
import vimconnector
42 from requests
.exceptions
import ConnectionError
44 __author__
= "Igor D.C."
45 __date__
= "$23-aug-2017 23:59:59$"
47 # Variables Used in TestNewVmInstance Class
49 description
= "my firewall"
51 image_id
= "408b73-e9cc-5a6a-t270-82cc4811bd4a"
52 flavor_id
= "208b73-e9cc-5a6a-t270-82cc4811bd4a"
53 affinity_group_list
= []
58 {"size": 10, "image_id": image_id
},
61 availability_zone_index
= 0
62 availability_zone_list
= ["nova"]
63 floating_network_vim_id
= "108b73-e9cc-5a6a-t270-82cc4811bd4a"
64 net_id
= "83372685-f67f-49fd-8722-eabb7692fc22"
65 net2_id
= "46472685-f67f-49fd-8722-eabb7692fc22"
66 mac_address
= "00:00:5e:00:53:af"
67 port_id
= "03372685-f67f-49fd-8722-eabb7692fc22"
68 time_return_value
= 156570000
69 port2_id
= "17472685-f67f-49fd-8722-eabb7692fc22"
70 root_vol_id
= "tc408b73-r9cc-5a6a-a270-82cc4811bd4a"
72 volume_id
= "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"
73 volume_id2
= "o4e0e83-b9uu-4akk-a234-89cc4811bd4a"
74 volume_id3
= "44e0e83-t9uu-4akk-a234-p9cc4811bd4a"
75 volume_id4
= "91bf5674-5b85-41d1-aa3b-4848e2691088"
76 virtual_mac_id
= "64e0e83-t9uu-4akk-a234-p9cc4811bd4a"
77 created_items_all_true
= {
78 f
"floating_ip:{floating_network_vim_id}": True,
79 f
"volume:{volume_id}": True,
80 f
"port:{port_id}": True,
84 # Variables used in TestNewFlavor Class
85 name1
= "sample-flavor"
88 "cpu-quota": {"limit": 3},
89 "mem-quota": {"limit": 1},
90 "mempage-size": "LARGE",
91 "cpu-pinning-policy": "DEDICATED",
92 "mem-policy": "STRICT",
100 "extended": extended
,
111 def check_if_assert_not_called(mocks
: list):
112 for mocking
in mocks
:
113 mocking
.assert_not_called()
117 def __init__(self
, s
, type="__DEFAULT__", name
="", id=""):
119 self
.volume_type
= type
125 def __init__(self
, name
="", status
="", flavor
="", id=""):
132 class CopyingMock(MagicMock
):
133 def __call__(self
, *args
, **kwargs
):
134 args
= deepcopy(args
)
135 kwargs
= deepcopy(kwargs
)
136 return super(CopyingMock
, self
).__call
__(*args
, **kwargs
)
139 class TestNewVmInstance(unittest
.TestCase
):
140 @patch("logging.getLogger", autospec
=True)
141 def setUp(self
, mock_logger
):
142 # Instantiate dummy VIM connector so we can test it
143 # It throws exception because of dummy parameters,
144 # We are disabling the logging of exception not to print them to console.
145 mock_logger
= logging
.getLogger()
146 mock_logger
.disabled
= True
147 self
.vimconn
= vimconnector(
157 self
.vimconn
.neutron
= CopyingMock()
158 self
.vimconn
.nova
= CopyingMock()
159 self
.vimconn
.cinder
= CopyingMock()
160 self
.server
= MagicMock(object, autospec
=True)
161 self
.server
.tenant_id
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
162 self
.server
.id = "908b73-e9cc-5a6a-t270-82cc4811bd4a"
163 self
.vimconn
.config
["security_groups"] = "default"
164 self
.vimconn
.config
["keypair"] = "my_keypair"
165 self
.vimconn
.security_groups_id
= "12345"
166 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.32"
167 self
.vimconn
.logger
= CopyingMock()
169 @patch.object(vimconnector
, "_get_ids_from_name")
170 def test_prepare_port_dict_security_security_groups_exists_in_config(
173 """In VIM config security_groups exists, net port_security is True
174 no_port_security_extension does not exist.
176 self
.vimconn
.config
= {"security_groups": "example_security_group"}
177 net
= {"port_security": True}
179 result_dict
= {"security_groups": "12345"}
181 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
182 self
.assertDictEqual(result_dict
, port_dict
)
183 mock_get_ids
.assert_not_called()
185 @patch.object(vimconnector
, "_get_ids_from_name")
186 def test_prepare_port_dict_security_security_groups_exists_in_config_no_security_groups_id(
189 """In VIM config Security_groups exists, net port_security is True, vim security_groups_id does not exist,
190 no_port_security_extension does not exist.
192 self
.vimconn
.config
= {"security_groups": "example_security_group"}
193 self
.vimconn
.security_groups_id
= None
194 net
= {"port_security": True}
196 result_dict
= {"security_groups": None}
198 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
199 self
.assertDictEqual(result_dict
, port_dict
)
200 mock_get_ids
.assert_called()
202 @patch.object(vimconnector
, "_get_ids_from_name")
203 def test_prepare_port_dict_security_security_groups_exists_security_extension_true_in_config(
206 """In VIM config security_groups exists, net port_security is True, in VIM security_groups_id exists,
207 no_port_security_extension set to True.
209 self
.vimconn
.config
= {
210 "security_groups": "example_security_group",
211 "no_port_security_extension": True,
213 net
= {"port_security": True}
217 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
218 self
.assertDictEqual(result_dict
, port_dict
)
219 mock_get_ids
.assert_not_called()
221 @patch.object(vimconnector
, "_get_ids_from_name")
222 def test_prepare_port_dict_security_no_security_groups_in_config(
225 """In VIM config security_group does not exist, net port_security True, in VIM security_groups_id exists,
226 no_port_security_extension does not exist."""
227 self
.vimconn
.config
= {}
228 net
= {"port_security": True}
232 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
233 self
.assertDictEqual(result_dict
, port_dict
)
234 mock_get_ids
.assert_not_called()
236 @patch.object(vimconnector
, "_get_ids_from_name")
237 def test_prepare_port_dict_security_no_security_groups_security_extension_true_in_config(
240 """Security_group does not exist, net port_security is True, in VIM security_groups_id exists,
241 no_port_security_extension set to True."""
242 self
.vimconn
.config
= {"no_port_security_extension": True}
243 net
= {"port_security": True}
247 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
248 self
.assertDictEqual(result_dict
, port_dict
)
249 mock_get_ids
.assert_not_called()
251 @patch.object(vimconnector
, "_get_ids_from_name")
252 def test_prepare_port_dict_security_security_groups_exists_net_port_security_false(
255 """In VIM config security_group exists, net port_security False, security_groups_id exists,
256 no_port_security_extension does not exist."""
257 self
.vimconn
.config
= {"security_groups": "example_security_group"}
258 net
= {"port_security": False}
262 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
263 self
.assertDictEqual(result_dict
, port_dict
)
264 mock_get_ids
.assert_not_called()
266 @patch.object(vimconnector
, "_get_ids_from_name")
267 def test_prepare_port_dict_security_net_port_security_false_port_security_extension_true(
270 """In VIM config security_group exists, net port_security False, security_groups_id exists,
271 no_port_security_extension set to True."""
272 self
.vimconn
.config
= {
273 "security_groups": "example_security_group",
274 "no_port_security_extension": True,
276 net
= {"port_security": False}
280 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
281 self
.assertDictEqual(result_dict
, port_dict
)
282 mock_get_ids
.assert_not_called()
284 def test_prepare_port_dict_binding_net_type_virtual(self
):
285 """net type is virtual."""
286 net
= {"type": "virtual"}
289 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
290 self
.assertDictEqual(result_dict
, port_dict
)
292 def test_prepare_port_dict_binding_net_type_vf(self
):
293 """net type is VF, vim_type is not VIO."""
295 self
.vimconn
.vim_type
= None
297 result_dict
= {"binding:vnic_type": "direct"}
298 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
299 self
.assertDictEqual(port_dict
, result_dict
)
301 def test_prepare_port_dict_binding_net_type_sriov_vim_type_vio(self
):
302 """net type is SR-IOV, vim_type is VIO."""
303 net
= {"type": "SR-IOV"}
304 self
.vimconn
.vim_type
= "VIO"
307 "binding:vnic_type": "direct",
308 "port_security_enabled": False,
309 "provider_security_groups": [],
310 "security_groups": [],
312 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
313 self
.assertDictEqual(port_dict
, result_dict
)
315 def test_prepare_port_dict_binding_net_type_passthrough(self
):
316 """net type is pci-passthrough."""
317 net
= {"type": "PCI-PASSTHROUGH"}
320 "binding:vnic_type": "direct-physical",
322 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
323 self
.assertDictEqual(port_dict
, result_dict
)
325 def test_prepare_port_dict_binding_no_net_type(self
):
326 """net type is missing."""
329 with self
.assertRaises(VimConnException
) as err
:
330 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
331 self
.assertEqual(str(err
.exception
), "Type is missing in the network details.")
333 def test_set_fixed_ip(self
):
334 """new_port has fixed ip."""
338 "fixed_ips": [{"ip_address": "10.1.2.3"}, {"ip_address": "20.1.2.3"}]
341 result
= {"ip": "10.1.2.3"}
342 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
343 self
.assertDictEqual(net
, result
)
345 def test_set_fixed_ip_no_fixed_ip(self
):
346 """new_port does not have fixed ip."""
348 new_port
= {"port": {}}
349 result
= {"ip": None}
350 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
351 self
.assertDictEqual(net
, result
)
353 def test_set_fixed_ip_raise_exception(self
):
354 """new_port does not have port details."""
357 with self
.assertRaises(Exception) as err
:
358 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
359 self
.assertEqual(type(err
.exception
), KeyError)
361 def test_prepare_port_dict_mac_ip_addr(self
):
362 """mac address and ip address exist."""
364 "mac_address": mac_address
,
365 "ip_address": "10.0.1.5",
369 "mac_address": mac_address
,
370 "fixed_ips": [{"ip_address": "10.0.1.5"}],
372 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
373 self
.assertDictEqual(port_dict
, result_dict
)
375 def test_prepare_port_dict_mac_ip_addr_empty_net(self
):
376 """mac address and ip address does not exist."""
380 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
381 self
.assertDictEqual(port_dict
, result_dict
)
383 def test_prepare_port_dict_mac_ip_addr_dual(self
):
384 """mac address, ipv4 and ipv6 addresses exist."""
386 "mac_address": mac_address
,
387 "ip_address": ["10.0.1.5", "2345:0425:2CA1:0000:0000:0567:5673:23b5"],
391 "mac_address": mac_address
,
393 {"ip_address": "10.0.1.5"},
394 {"ip_address": "2345:0425:2CA1:0000:0000:0567:5673:23b5"},
397 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
398 self
.assertDictEqual(port_dict
, result_dict
)
400 def test_prepare_port_dict_mac_ip_addr_dual_ip_addr_is_not_list(self
):
401 """mac address, ipv4 and ipv6 addresses exist."""
403 "mac_address": mac_address
,
404 "ip_address": "10.0.1.5",
408 "mac_address": mac_address
,
410 {"ip_address": "10.0.1.5"},
413 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
414 self
.assertDictEqual(port_dict
, result_dict
)
416 def test_prepare_port_dict_mac_ip_addr_dual_net_without_ip_addr(self
):
417 """mac address, ipv4 and ipv6 addresses exist."""
419 "mac_address": mac_address
,
424 "mac_address": mac_address
,
426 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
427 self
.assertDictEqual(port_dict
, result_dict
)
429 def test_prepare_port_dict_mac_ip_addr_dual_net_without_mac_addr(self
):
430 """mac address, ipv4 and ipv6 addresses exist."""
432 "ip_address": ["10.0.1.5", "2345:0425:2CA1:0000:0000:0567:5673:23b5"],
437 {"ip_address": "10.0.1.5"},
438 {"ip_address": "2345:0425:2CA1:0000:0000:0567:5673:23b5"},
441 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
442 self
.assertDictEqual(port_dict
, result_dict
)
444 def test_create_new_port(self
):
445 """new port has id and mac address."""
449 "mac_address": mac_address
,
452 self
.vimconn
.neutron
.create_port
.return_value
= new_port
453 net
, port_dict
, created_items
= {}, {}, {}
454 expected_result
= new_port
456 "mac_address": mac_address
,
459 expected_created_items
= {f
"port:{port_id}": True}
460 result
= self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
461 self
.assertDictEqual(result
, expected_result
)
462 self
.assertEqual(net
, expected_net
)
463 self
.assertEqual(created_items
, expected_created_items
)
464 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
466 def test_create_new_port_without_mac_or_id(self
):
467 """new port does not have mac address or ID."""
469 self
.vimconn
.neutron
.create_port
.return_value
= new_port
470 net
, port_dict
, created_items
= {}, {}, {}
471 with self
.assertRaises(KeyError):
472 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
473 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
475 def test_create_new_port_neutron_create_port_raises_exception(self
):
476 """Neutron create port raises exception."""
477 self
.vimconn
.neutron
.create_port
.side_effect
= VimConnException(
478 "New port is not created."
480 net
, port_dict
, created_items
= {}, {}, {}
481 with self
.assertRaises(VimConnException
):
482 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
483 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
485 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
486 @patch.object(vimconnector
, "_prepare_port_dict_binding")
487 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
488 @patch.object(vimconnector
, "_create_new_port")
489 @patch.object(vimconnector
, "_set_fixed_ip")
490 def test_create_port(
493 mock_create_new_port
,
494 mock_prepare_port_dict_mac_ip_addr
,
495 mock_prepare_port_dict_binding
,
496 mock_prepare_port_dict_security_groups
,
498 """Net has name, type, net-id."""
502 "name": "management",
509 "mac_address": mac_address
,
510 "name": "management",
511 "fixed_ips": [{"ip_address": ip_addr1
}],
514 mock_create_new_port
.return_value
= new_port
520 "network_id": net_id
,
521 "name": "management",
522 "admin_state_up": True,
525 new_port_result
, port_result
= self
.vimconn
._create
_port
(
526 net
, name
, created_items
529 self
.assertDictEqual(new_port_result
, new_port
)
530 self
.assertDictEqual(port_result
, expected_port
)
532 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
533 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
534 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
535 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
536 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
538 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
539 @patch.object(vimconnector
, "_prepare_port_dict_binding")
540 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
541 @patch.object(vimconnector
, "_create_new_port")
542 @patch.object(vimconnector
, "_set_fixed_ip")
543 def test_create_port_no_port_name(
546 mock_create_new_port
,
547 mock_prepare_port_dict_mac_ip_addr
,
548 mock_prepare_port_dict_binding
,
549 mock_prepare_port_dict_security_groups
,
551 """Net has no name."""
560 "mac_address": mac_address
,
562 "fixed_ips": [{"ip_address": ip_addr1
}],
565 mock_create_new_port
.return_value
= new_port
571 "network_id": net_id
,
572 "admin_state_up": True,
576 new_port_result
, port_result
= self
.vimconn
._create
_port
(
577 net
, name
, created_items
580 self
.assertDictEqual(new_port_result
, new_port
)
581 self
.assertDictEqual(port_result
, expected_port
)
583 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
584 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
585 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
586 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
587 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
589 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
590 @patch.object(vimconnector
, "_prepare_port_dict_binding")
591 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
592 @patch.object(vimconnector
, "_create_new_port")
593 @patch.object(vimconnector
, "_set_fixed_ip")
594 def test_create_port_nova_api_version_smaller_than_232(
597 mock_create_new_port
,
598 mock_prepare_port_dict_mac_ip_addr
,
599 mock_prepare_port_dict_binding
,
600 mock_prepare_port_dict_security_groups
,
602 """Nova api version is smaller than 2.32."""
603 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.30"
612 "mac_address": mac_address
,
614 "fixed_ips": [{"ip_address": ip_addr1
}],
617 mock_create_new_port
.return_value
= new_port
622 "network_id": net_id
,
623 "admin_state_up": True,
627 new_port_result
, port_result
= self
.vimconn
._create
_port
(
628 net
, name
, created_items
631 self
.assertDictEqual(new_port_result
, new_port
)
632 self
.assertDictEqual(port_result
, expected_port
)
634 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
635 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
636 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
637 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
638 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
640 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
641 @patch.object(vimconnector
, "_prepare_port_dict_binding")
642 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
643 @patch.object(vimconnector
, "_create_new_port")
644 @patch.object(vimconnector
, "_set_fixed_ip")
645 def test_create_port_create_new_port_raise_exception(
648 mock_create_new_port
,
649 mock_prepare_port_dict_mac_ip_addr
,
650 mock_prepare_port_dict_binding
,
651 mock_prepare_port_dict_security_groups
,
653 """_create_new_port method raises exception."""
659 mock_create_new_port
.side_effect
= Exception
661 "network_id": net_id
,
662 "admin_state_up": True,
666 with self
.assertRaises(Exception):
667 self
.vimconn
._create
_port
(net
, name
, created_items
)
669 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
670 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
671 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
672 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
673 mock_set_fixed_ip
.assert_not_called()
675 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
676 @patch.object(vimconnector
, "_prepare_port_dict_binding")
677 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
678 @patch.object(vimconnector
, "_create_new_port")
679 @patch.object(vimconnector
, "_set_fixed_ip")
680 def test_create_port_create_sec_groups_raises_exception(
683 mock_create_new_port
,
684 mock_prepare_port_dict_mac_ip_addr
,
685 mock_prepare_port_dict_binding
,
686 mock_prepare_port_dict_security_groups
,
688 """_prepare_port_dict_security_groups method raises exception."""
694 mock_prepare_port_dict_security_groups
.side_effect
= Exception
696 "network_id": net_id
,
697 "admin_state_up": True,
701 with self
.assertRaises(Exception):
702 self
.vimconn
._create
_port
(net
, name
, created_items
)
704 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
706 mock_prepare_port_dict_binding
.assert_not_called()
707 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
708 mock_create_new_port
.assert_not_called()
709 mock_set_fixed_ip
.assert_not_called()
711 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
712 @patch.object(vimconnector
, "_prepare_port_dict_binding")
713 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
714 @patch.object(vimconnector
, "_create_new_port")
715 @patch.object(vimconnector
, "_set_fixed_ip")
716 def test_create_port_create_port_dict_binding_raise_exception(
719 mock_create_new_port
,
720 mock_prepare_port_dict_mac_ip_addr
,
721 mock_prepare_port_dict_binding
,
722 mock_prepare_port_dict_security_groups
,
724 """_prepare_port_dict_binding method raises exception."""
731 mock_prepare_port_dict_binding
.side_effect
= Exception
733 "network_id": net_id
,
734 "admin_state_up": True,
738 with self
.assertRaises(Exception):
739 self
.vimconn
._create
_port
(net
, name
, created_items
)
741 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
743 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
745 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
746 mock_create_new_port
.assert_not_called()
747 mock_set_fixed_ip
.assert_not_called()
749 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
750 @patch.object(vimconnector
, "_prepare_port_dict_binding")
751 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
752 @patch.object(vimconnector
, "_create_new_port")
753 @patch.object(vimconnector
, "_set_fixed_ip")
754 def test_create_port_create_port_mac_ip_addr_raise_exception(
757 mock_create_new_port
,
758 mock_prepare_port_dict_mac_ip_addr
,
759 mock_prepare_port_dict_binding
,
760 mock_prepare_port_dict_security_groups
,
762 """prepare_port_dict_mac_ip_addr method raises exception."""
768 mock_prepare_port_dict_mac_ip_addr
.side_effect
= Exception
770 "network_id": net_id
,
771 "admin_state_up": True,
775 with self
.assertRaises(Exception):
776 self
.vimconn
._create
_port
(net
, name
, created_items
)
778 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
779 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
780 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
782 mock_create_new_port
.assert_not_called()
783 mock_set_fixed_ip
.assert_not_called()
785 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
786 @patch.object(vimconnector
, "_prepare_port_dict_binding")
787 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
788 @patch.object(vimconnector
, "_create_new_port")
789 @patch.object(vimconnector
, "_set_fixed_ip")
790 def test_create_port_create_port_set_fixed_ip_raise_exception(
793 mock_create_new_port
,
794 mock_prepare_port_dict_mac_ip_addr
,
795 mock_prepare_port_dict_binding
,
796 mock_prepare_port_dict_security_groups
,
798 """_set_fixed_ip method raises exception."""
804 mock_set_fixed_ip
.side_effect
= VimConnException(
805 "Port detail is missing in new_port."
808 "network_id": net_id
,
809 "admin_state_up": True,
815 "mac_address": mac_address
,
817 "fixed_ips": [{"ip_address": ip_addr1
}],
820 mock_create_new_port
.return_value
= new_port
822 with self
.assertRaises(VimConnException
):
823 self
.vimconn
._create
_port
(net
, name
, created_items
)
825 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
826 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
827 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
828 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
829 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
831 @patch.object(vimconnector
, "_reload_connection")
832 @patch.object(vimconnector
, "_create_port")
833 def test_prepare_network_for_vm_instance_no_net_id(
834 self
, mock_create_port
, mock_reload_connection
836 """Nets do not have net_id"""
837 mock_reload_connection
.side_effect
= None
842 "port_security": False,
843 "exit_on_floating_ip_error": False,
844 "port_security_disable_strategy": "full",
847 "port_security": True,
848 "exit_on_floating_ip_error": False,
853 external_network
, no_secured_ports
= [], []
854 expected_external_network
, expected_no_secured_ports
= [], []
855 expected_net_list_vim
= []
857 self
.vimconn
._prepare
_network
_for
_vminstance
(
865 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
866 self
.assertEqual(external_network
, expected_external_network
)
867 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
869 mock_create_port
.assert_not_called()
871 @patch.object(vimconnector
, "_reload_connection")
872 @patch.object(vimconnector
, "_create_port")
873 def test_prepare_network_for_vm_instance_empty_net_list(
874 self
, mock_create_port
, mock_reload_connection
876 """Net list is empty."""
877 mock_reload_connection
.side_effect
= None
880 external_network
, no_secured_ports
= [], []
881 expected_external_network
, expected_no_secured_ports
= [], []
882 expected_net_list_vim
= []
884 self
.vimconn
._prepare
_network
_for
_vminstance
(
892 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
893 self
.assertEqual(external_network
, expected_external_network
)
894 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
896 mock_create_port
.assert_not_called()
898 @patch.object(vimconnector
, "_reload_connection")
899 @patch.object(vimconnector
, "_create_port")
900 def test_prepare_network_for_vm_instance_use_floating_ip_false_mgmt_net(
901 self
, mock_create_port
, mock_reload_connection
903 """Nets have net-id, floating_ip False, mgmt network."""
904 mock_reload_connection
.side_effect
= None
909 "floating_ip": False,
914 mock_create_port
.side_effect
= [
919 "mac_address": mac_address
,
923 {"port-dict": port2_id
},
926 external_network
, no_secured_ports
= [], []
927 expected_external_network
, expected_no_secured_ports
= [], []
928 expected_net_list_vim
= [{"port-dict": port2_id
}]
929 self
.vimconn
._prepare
_network
_for
_vminstance
(
937 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
938 self
.assertEqual(external_network
, expected_external_network
)
939 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
941 mock_create_port
.assert_called_once_with(
944 "floating_ip": False,
951 @patch.object(vimconnector
, "_reload_connection")
952 def test_prepare_network_for_vm_instance_mgmt_net_net_port_security_and_floating_ip_true(
953 self
, mock_reload_connection
955 """Nets have net-id, use_floating_ip False in VIM config, mgmt network, net floating_ip is True."""
956 self
.vimconn
.config
["use_floating_ip"] = False
957 mock_create_port
= CopyingMock()
958 mock_reload_connection
.side_effect
= None
968 mock_create_port
.side_effect
= [
973 "mac_address": mac_address
,
977 {"port-dict": port2_id
},
980 external_network
, no_secured_ports
= [], []
981 expected_external_network
= [
986 "exit_on_floating_ip_error": True,
989 expected_no_secured_ports
= []
990 expected_net_list_vim
= [{"port-dict": port2_id
}]
991 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
992 self
.vimconn
._prepare
_network
_for
_vminstance
(
1000 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1001 self
.assertEqual(external_network
, expected_external_network
)
1002 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1004 mock_create_port
.assert_called_once_with(
1007 "floating_ip": True,
1014 @patch.object(vimconnector
, "_reload_connection")
1015 def test_prepare_network_for_vm_instance_use_floating_ip_true_mgmt_net_port_security_false(
1016 self
, mock_reload_connection
1018 """Nets have net-id, use_floating_ip is True in VIM config, mgmt network, net port security is False."""
1019 mock_create_port
= CopyingMock()
1020 self
.vimconn
.config
["use_floating_ip"] = True
1021 self
.vimconn
.config
["no_port_security_extension"] = False
1022 mock_reload_connection
.side_effect
= None
1029 "port_security": False,
1030 "exit_on_floating_ip_error": False,
1031 "port_security_disable_strategy": "full",
1035 mock_create_port
.side_effect
= [
1040 "mac_address": mac_address
,
1044 {"port-dict": port2_id
},
1047 external_network
, no_secured_ports
= [], []
1048 expected_external_network
= [
1052 "port_security": False,
1053 "exit_on_floating_ip_error": False,
1054 "port_security_disable_strategy": "full",
1055 "floating_ip": True,
1058 expected_no_secured_ports
= [(port2_id
, "full")]
1059 expected_net_list_vim
= [{"port-dict": port2_id
}]
1060 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1061 self
.vimconn
._prepare
_network
_for
_vminstance
(
1070 mock_create_port
.assert_called_once_with(
1074 "port_security": False,
1075 "exit_on_floating_ip_error": False,
1076 "port_security_disable_strategy": "full",
1081 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1082 self
.assertEqual(external_network
, expected_external_network
)
1083 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1085 @patch.object(vimconnector
, "_reload_connection")
1086 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_false(
1087 self
, mock_reload_connection
1089 """Nets have net-id, use_floating_ip True in VIM config, non-mgmt network, port security is False."""
1090 mock_create_port
= CopyingMock()
1091 self
.vimconn
.config
["use_floating_ip"] = True
1092 self
.vimconn
.config
["no_port_security_extension"] = False
1093 mock_reload_connection
.side_effect
= None
1100 "port_security": False,
1101 "port_security_disable_strategy": "full",
1105 mock_create_port
.side_effect
= [
1110 "mac_address": mac_address
,
1114 {"port-dict": port2_id
},
1117 external_network
, no_secured_ports
= [], []
1118 expected_external_network
= []
1119 expected_no_secured_ports
= [(port2_id
, "full")]
1120 expected_net_list_vim
= [{"port-dict": port2_id
}]
1121 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1122 self
.vimconn
._prepare
_network
_for
_vminstance
(
1131 mock_create_port
.assert_called_once_with(
1135 "port_security": False,
1136 "port_security_disable_strategy": "full",
1141 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1142 self
.assertEqual(external_network
, expected_external_network
)
1143 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1145 @patch.object(vimconnector
, "_reload_connection")
1146 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_true(
1147 self
, mock_reload_connection
1149 """Nets have net-id, use_floating_ip is True in VIM config, non-mgmt network, net port security is True."""
1150 mock_create_port
= CopyingMock()
1151 self
.vimconn
.config
["use_floating_ip"] = True
1152 self
.vimconn
.config
["no_port_security_extension"] = True
1153 mock_reload_connection
.side_effect
= None
1160 "port_security": True,
1161 "port_security_disable_strategy": "full",
1165 mock_create_port
.side_effect
= [
1170 "mac_address": mac_address
,
1174 {"port-dict": port2_id
},
1177 external_network
, no_secured_ports
= [], []
1178 expected_external_network
= []
1179 expected_no_secured_ports
= []
1180 expected_net_list_vim
= [{"port-dict": port2_id
}]
1181 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1182 self
.vimconn
._prepare
_network
_for
_vminstance
(
1191 mock_create_port
.assert_called_once_with(
1195 "port_security": True,
1196 "port_security_disable_strategy": "full",
1201 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1202 self
.assertEqual(external_network
, expected_external_network
)
1203 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1205 @patch.object(vimconnector
, "_reload_connection")
1206 def test_prepare_network_for_vm_instance_create_port_raise_exception(
1207 self
, mock_reload_connection
1209 """_create_port method raise exception."""
1210 mock_create_port
= CopyingMock()
1211 self
.vimconn
.config
["use_floating_ip"] = True
1212 self
.vimconn
.config
["no_port_security_extension"] = True
1213 mock_reload_connection
.side_effect
= None
1220 "port_security": True,
1221 "port_security_disable_strategy": "full",
1225 mock_create_port
.side_effect
= KeyError
1226 external_network
, no_secured_ports
= [], []
1227 expected_external_network
= []
1228 expected_no_secured_ports
= []
1229 expected_net_list_vim
= []
1230 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1231 with self
.assertRaises(Exception) as err
:
1232 self
.vimconn
._prepare
_network
_for
_vminstance
(
1241 self
.assertEqual(type(err
.exception
), KeyError)
1243 mock_create_port
.assert_called_once_with(
1247 "port_security": True,
1248 "port_security_disable_strategy": "full",
1253 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1254 self
.assertEqual(external_network
, expected_external_network
)
1255 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1257 @patch.object(vimconnector
, "_reload_connection")
1258 def test_prepare_network_for_vm_instance_reload_connection_raise_exception(
1259 self
, mock_reload_connection
1261 """_reload_connection method raises exception."""
1262 mock_create_port
= CopyingMock()
1263 mock_reload_connection
.side_effect
= VimConnConnectionException(
1264 "Connection failed."
1266 self
.vimconn
.config
["use_floating_ip"] = True
1267 self
.vimconn
.config
["no_port_security_extension"] = True
1274 "port_security": True,
1275 "port_security_disable_strategy": "full",
1279 mock_create_port
.side_effect
= None
1280 external_network
, no_secured_ports
= [], []
1281 expected_external_network
= []
1282 expected_no_secured_ports
= []
1283 expected_net_list_vim
= []
1284 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1285 with self
.assertRaises(Exception) as err
:
1286 self
.vimconn
._prepare
_network
_for
_vminstance
(
1295 self
.assertEqual(type(err
.exception
), VimConnConnectionException
)
1296 self
.assertEqual(str(err
.exception
), "Connection failed.")
1297 mock_reload_connection
.assert_called_once()
1298 mock_create_port
.assert_not_called()
1299 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1300 self
.assertEqual(external_network
, expected_external_network
)
1301 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1303 def test_prepare_persistent_root_volumes_vim_using_volume_id(self
):
1304 """Existing persistent root volume with vim_volume_id."""
1305 vm_av_zone
= ["nova"]
1306 base_disk_index
= ord("a")
1307 disk
= {"vim_volume_id": volume_id
}
1308 block_device_mapping
= {}
1309 existing_vim_volumes
= []
1311 expected_boot_vol_id
= None
1312 expected_block_device_mapping
= {"vda": volume_id
}
1313 expected_existing_vim_volumes
= [{"id": volume_id
}]
1314 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1319 block_device_mapping
,
1320 existing_vim_volumes
,
1323 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1324 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1325 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1326 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1328 @patch.object(vimconnector
, "update_block_device_mapping")
1329 def test__prepare_shared_volumes_vim_using_volume_id(
1330 self
, mock_update_block_device_mapping
1332 """Existing persistent non root volume with vim_volume_id.
1334 def __init__(self, s, type="__DEFAULT__", name="", id=""):
1336 self.volume_type = type
1339 volumes = {"shared-volume": volume_id4}
1341 The device mappeing BEFORE is: {}
1342 The device mappeing AFTER is: {'vdb': '8ca50cc6-a779-4513-a1f3-900b8b3987d2'}
1344 base_disk_index
= ord("b")
1345 disk
= {"name": "shared-volume"}
1346 block_device_mapping
= {}
1347 existing_vim_volumes
= []
1349 expected_block_device_mapping
= {}
1350 self
.vimconn
.cinder
.volumes
.list.return_value
= [
1351 Volume("available", "multiattach", "shared-volume", volume_id4
)
1353 self
.vimconn
.cinder
.volumes
.get
.return_value
.id = volume_id4
1354 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1355 self
.vimconn
._prepare
_shared
_volumes
(
1359 block_device_mapping
,
1360 existing_vim_volumes
,
1363 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id4
)
1364 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1366 @patch.object(vimconnector
, "update_block_device_mapping")
1367 def test_prepare_persistent_non_root_volumes_vim_using_volume_id(
1368 self
, mock_update_block_device_mapping
1370 """Existing persistent non root volume with vim_volume_id."""
1371 vm_av_zone
= ["nova"]
1372 base_disk_index
= ord("b")
1373 disk
= {"vim_volume_id": volume_id
}
1374 block_device_mapping
= {}
1375 existing_vim_volumes
= []
1377 expected_block_device_mapping
= {"vdb": volume_id
}
1378 expected_existing_vim_volumes
= [{"id": volume_id
}]
1379 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1383 block_device_mapping
,
1385 existing_vim_volumes
,
1388 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1389 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1390 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1391 mock_update_block_device_mapping
.assert_not_called()
1393 @patch.object(vimconnector
, "update_block_device_mapping")
1394 def test_prepare_persistent_root_volumes_using_vim_id(
1395 self
, mock_update_block_device_mapping
1397 """Existing persistent root volume with vim_id."""
1398 vm_av_zone
= ["nova"]
1399 base_disk_index
= ord("a")
1400 disk
= {"vim_id": volume_id
}
1401 block_device_mapping
= {}
1402 existing_vim_volumes
= []
1404 expected_boot_vol_id
= None
1405 expected_block_device_mapping
= {"vda": volume_id
}
1406 expected_existing_vim_volumes
= [{"id": volume_id
}]
1407 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1412 block_device_mapping
,
1413 existing_vim_volumes
,
1416 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1417 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1418 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1419 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1420 mock_update_block_device_mapping
.assert_not_called()
1422 @patch.object(vimconnector
, "update_block_device_mapping")
1423 def test_prepare_persistent_non_root_volumes_using_vim_id(
1424 self
, mock_update_block_device_mapping
1426 """Existing persistent root volume with vim_id."""
1427 vm_av_zone
= ["nova"]
1428 base_disk_index
= ord("b")
1429 disk
= {"vim_id": volume_id
}
1430 block_device_mapping
= {}
1431 existing_vim_volumes
= []
1434 expected_block_device_mapping
= {"vdb": volume_id
}
1435 expected_existing_vim_volumes
= [{"id": volume_id
}]
1436 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1440 block_device_mapping
,
1442 existing_vim_volumes
,
1446 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1447 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1448 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1449 mock_update_block_device_mapping
.assert_not_called()
1451 @patch.object(vimconnector
, "update_block_device_mapping")
1452 def test_prepare_persistent_root_volumes_create(
1453 self
, mock_update_block_device_mapping
1455 """Create persistent root volume."""
1456 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1457 vm_av_zone
= ["nova"]
1458 base_disk_index
= ord("a")
1459 disk
= {"size": 10, "image_id": image_id
}
1460 block_device_mapping
= {}
1461 existing_vim_volumes
= []
1463 expected_boot_vol_id
= volume_id2
1464 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1469 block_device_mapping
,
1470 existing_vim_volumes
,
1473 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1474 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1478 availability_zone
=["nova"],
1480 mock_update_block_device_mapping
.assert_called_once()
1481 _call_mock_update_block_device_mapping
= (
1482 mock_update_block_device_mapping
.call_args_list
1485 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1486 block_device_mapping
,
1489 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1491 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1493 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1496 @patch.object(vimconnector
, "update_block_device_mapping")
1497 def test_prepare_persistent_root_volumes_create_with_keep(
1498 self
, mock_update_block_device_mapping
1500 """Create persistent root volume, disk has keep parameter."""
1501 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1502 vm_av_zone
= ["nova"]
1503 base_disk_index
= ord("a")
1504 disk
= {"size": 10, "image_id": image_id
, "keep": True}
1505 block_device_mapping
= {}
1506 existing_vim_volumes
= []
1508 expected_boot_vol_id
= volume_id2
1509 expected_existing_vim_volumes
= []
1510 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1515 block_device_mapping
,
1516 existing_vim_volumes
,
1519 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1520 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1521 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1525 availability_zone
=["nova"],
1527 mock_update_block_device_mapping
.assert_called_once()
1528 _call_mock_update_block_device_mapping
= (
1529 mock_update_block_device_mapping
.call_args_list
1532 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1533 block_device_mapping
,
1536 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1538 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1540 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1543 @patch.object(vimconnector
, "update_block_device_mapping")
1544 def test_prepare_persistent_non_root_volumes_create(
1545 self
, mock_update_block_device_mapping
1547 """Create persistent non-root volume."""
1548 self
.vimconn
.cinder
= CopyingMock()
1549 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1550 vm_av_zone
= ["nova"]
1551 base_disk_index
= ord("a")
1553 block_device_mapping
= {}
1554 existing_vim_volumes
= []
1556 expected_existing_vim_volumes
= []
1557 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1561 block_device_mapping
,
1563 existing_vim_volumes
,
1567 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1568 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1569 size
=10, name
="basicvmvda", availability_zone
=["nova"]
1571 mock_update_block_device_mapping
.assert_called_once()
1572 _call_mock_update_block_device_mapping
= (
1573 mock_update_block_device_mapping
.call_args_list
1576 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1577 block_device_mapping
,
1580 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1582 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1584 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1587 @patch.object(vimconnector
, "update_block_device_mapping")
1588 def test_prepare_persistent_non_root_volumes_create_with_keep(
1589 self
, mock_update_block_device_mapping
1591 """Create persistent non-root volume."""
1592 self
.vimconn
.cinder
= CopyingMock()
1593 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1594 vm_av_zone
= ["nova"]
1595 base_disk_index
= ord("a")
1596 disk
= {"size": 10, "keep": True}
1597 block_device_mapping
= {}
1598 existing_vim_volumes
= []
1600 expected_existing_vim_volumes
= []
1601 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1605 block_device_mapping
,
1607 existing_vim_volumes
,
1611 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1612 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1613 size
=10, name
="basicvmvda", availability_zone
=["nova"]
1615 mock_update_block_device_mapping
.assert_called_once()
1616 _call_mock_update_block_device_mapping
= (
1617 mock_update_block_device_mapping
.call_args_list
1620 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1621 block_device_mapping
,
1624 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1626 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1628 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1631 @patch.object(vimconnector
, "update_block_device_mapping")
1632 def test_new_shared_volumes(self
, mock_update_block_device_mapping
):
1633 """Create shared volume."""
1636 name
= "my-shared-volume"
1639 self
.vimconn
.cinder
.volumes
.create
.return_value
= MyVolume()
1640 shared_volume_data
= {"size": 10, "name": "my-shared-volume"}
1641 result
= self
.vimconn
.new_shared_volumes(shared_volume_data
)
1642 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1643 size
=10, name
="my-shared-volume", volume_type
="multiattach"
1645 self
.assertEqual(result
[0], "my-shared-volume")
1646 self
.assertEqual(result
[1], volume_id4
)
1648 @patch.object(vimconnector
, "update_block_device_mapping")
1649 def test_prepare_persistent_root_volumes_create_raise_exception(
1650 self
, mock_update_block_device_mapping
1652 """Create persistent root volume raise exception."""
1653 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
1654 vm_av_zone
= ["nova"]
1655 base_disk_index
= ord("a")
1656 disk
= {"size": 10, "image_id": image_id
}
1657 block_device_mapping
= {}
1658 existing_vim_volumes
= []
1661 with self
.assertRaises(Exception):
1662 result
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1667 block_device_mapping
,
1668 existing_vim_volumes
,
1672 self
.assertEqual(result
, None)
1674 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1678 availability_zone
=["nova"],
1680 self
.assertEqual(existing_vim_volumes
, [])
1681 self
.assertEqual(block_device_mapping
, {})
1682 self
.assertEqual(created_items
, {})
1683 mock_update_block_device_mapping
.assert_not_called()
1685 @patch.object(vimconnector
, "update_block_device_mapping")
1686 def test_prepare_persistent_non_root_volumes_create_raise_exception(
1687 self
, mock_update_block_device_mapping
1689 """Create persistent non-root volume raise exception."""
1690 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
1691 vm_av_zone
= ["nova"]
1692 base_disk_index
= ord("b")
1694 block_device_mapping
= {}
1695 existing_vim_volumes
= []
1698 with self
.assertRaises(Exception):
1699 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1703 block_device_mapping
,
1705 existing_vim_volumes
,
1709 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1710 size
=10, name
="basicvmvdb", availability_zone
=["nova"]
1712 self
.assertEqual(existing_vim_volumes
, [])
1713 self
.assertEqual(block_device_mapping
, {})
1714 self
.assertEqual(created_items
, {})
1715 mock_update_block_device_mapping
.assert_not_called()
1717 @patch("time.sleep")
1718 def test_wait_for_created_volumes_availability_volume_status_available(
1721 """Created volume status is available."""
1723 created_items
= {f
"volume:{volume_id2}": True}
1724 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1726 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1727 elapsed_time
, created_items
1729 self
.assertEqual(result
, elapsed_time
)
1730 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1731 mock_sleep
.assert_not_called()
1733 @patch("time.sleep")
1734 def test_wait_for_existing_volumes_availability_volume_status_available(
1737 """Existing volume status is available."""
1739 existing_vim_volumes
= [{"id": volume_id2
}]
1740 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1742 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1743 elapsed_time
, existing_vim_volumes
1745 self
.assertEqual(result
, elapsed_time
)
1746 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1747 mock_sleep
.assert_not_called()
1749 @patch("time.sleep")
1750 def test_wait_for_created_volumes_availability_status_processing_multiple_volumes(
1753 """Created volume status is processing."""
1756 f
"volume:{volume_id2}": True,
1757 f
"volume:{volume_id3}": True,
1759 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1760 Volume("processing"),
1761 Volume("available"),
1762 Volume("available"),
1765 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1766 elapsed_time
, created_items
1768 self
.assertEqual(result
, 10)
1769 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
1770 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
1771 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
1772 self
.assertEqual(_call_mock_get_volumes
[2][0], (volume_id3
,))
1773 mock_sleep
.assert_called_with(5)
1774 self
.assertEqual(1, mock_sleep
.call_count
)
1776 @patch("time.sleep")
1777 def test_wait_for_existing_volumes_availability_status_processing_multiple_volumes(
1780 """Existing volume status is processing."""
1782 existing_vim_volumes
= [
1784 {"id": "44e0e83-b9uu-4akk-t234-p9cc4811bd4a"},
1786 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1787 Volume("processing"),
1788 Volume("available", "multiattach"),
1789 Volume("available"),
1792 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1793 elapsed_time
, existing_vim_volumes
1795 self
.assertEqual(result
, 10)
1796 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
1797 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
1798 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
1800 _call_mock_get_volumes
[2][0], ("44e0e83-b9uu-4akk-t234-p9cc4811bd4a",)
1802 mock_sleep
.assert_called_with(5)
1803 self
.assertEqual(1, mock_sleep
.call_count
)
1805 @patch("time.sleep")
1806 def test_wait_for_created_volumes_availability_volume_status_processing_timeout(
1809 """Created volume status is processing, elapsed time greater than timeout (1800)."""
1811 created_items
= {f
"volume:{volume_id2}": True}
1812 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1813 Volume("processing"),
1814 Volume("processing"),
1816 with
patch("time.sleep", mock_sleep
):
1817 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1818 elapsed_time
, created_items
1820 self
.assertEqual(result
, 1805)
1821 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1822 mock_sleep
.assert_not_called()
1824 @patch("time.sleep")
1825 def test_wait_for_existing_volumes_availability_volume_status_processing_timeout(
1828 """Exsiting volume status is processing, elapsed time greater than timeout (1800)."""
1830 existing_vim_volumes
= [{"id": volume_id2
}]
1831 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1832 Volume("processing"),
1833 Volume("processing"),
1836 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1837 elapsed_time
, existing_vim_volumes
1839 self
.assertEqual(result
, 1805)
1840 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1841 mock_sleep
.assert_not_called()
1843 @patch("time.sleep")
1844 def test_wait_for_created_volumes_availability_cinder_raise_exception(
1847 """Cinder get volumes raises exception for created volumes."""
1849 created_items
= {f
"volume:{volume_id2}": True}
1850 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
1851 with self
.assertRaises(Exception):
1852 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1853 elapsed_time
, created_items
1855 self
.assertEqual(result
, 1000)
1856 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1857 mock_sleep
.assert_not_called()
1859 @patch("time.sleep")
1860 def test_wait_for_existing_volumes_availability_cinder_raise_exception(
1863 """Cinder get volumes raises exception for existing volumes."""
1865 existing_vim_volumes
= [{"id": volume_id2
}]
1866 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
1867 with self
.assertRaises(Exception):
1868 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1869 elapsed_time
, existing_vim_volumes
1871 self
.assertEqual(result
, 1000)
1872 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1873 mock_sleep
.assert_not_called()
1875 @patch("time.sleep")
1876 def test_wait_for_created_volumes_availability_no_volume_in_created_items(
1879 """Created_items dict does not have volume-id."""
1883 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
1885 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1886 elapsed_time
, created_items
1888 self
.assertEqual(result
, 10)
1889 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1890 mock_sleep
.assert_not_called()
1892 @patch("time.sleep")
1893 def test_wait_for_existing_volumes_availability_no_volume_in_existing_vim_volumes(
1896 """Existing_vim_volumes list does not have volume."""
1898 existing_vim_volumes
= []
1900 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
1902 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1903 elapsed_time
, existing_vim_volumes
1905 self
.assertEqual(result
, 10)
1906 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1907 mock_sleep
.assert_not_called()
1909 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
1910 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
1911 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
1912 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
1913 def test_prepare_disk_for_vm_instance(
1915 mock_existing_vol_availability
,
1916 mock_created_vol_availability
,
1917 mock_non_root_volumes
,
1920 """Prepare disks for VM instance successfully."""
1921 existing_vim_volumes
= []
1923 block_device_mapping
= {}
1924 vm_av_zone
= ["nova"]
1926 mock_root_volumes
.return_value
= root_vol_id
1927 mock_created_vol_availability
.return_value
= 10
1928 mock_existing_vol_availability
.return_value
= 15
1929 self
.vimconn
.cinder
= CopyingMock()
1930 self
.vimconn
._prepare
_disk
_for
_vminstance
(
1932 existing_vim_volumes
,
1935 block_device_mapping
,
1938 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_called_once_with(
1941 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
1942 mock_existing_vol_availability
.assert_called_once_with(10, existing_vim_volumes
)
1943 self
.assertEqual(mock_root_volumes
.call_count
, 1)
1944 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
1945 mock_root_volumes
.assert_called_once_with(
1947 vm_av_zone
=["nova"],
1948 disk
={"size": 10, "image_id": image_id
},
1950 block_device_mapping
={},
1951 existing_vim_volumes
=[],
1954 mock_non_root_volumes
.assert_called_once_with(
1957 vm_av_zone
=["nova"],
1959 block_device_mapping
={},
1960 existing_vim_volumes
=[],
1964 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
1965 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
1966 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
1967 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
1968 def test_prepare_disk_for_vm_instance_timeout_exceeded(
1970 mock_existing_vol_availability
,
1971 mock_created_vol_availability
,
1972 mock_non_root_volumes
,
1975 """Timeout exceeded while waiting for disks."""
1976 existing_vim_volumes
= []
1978 vm_av_zone
= ["nova"]
1979 block_device_mapping
= {}
1981 mock_root_volumes
.return_value
= root_vol_id
1982 mock_created_vol_availability
.return_value
= 1700
1983 mock_existing_vol_availability
.return_value
= 1900
1985 with self
.assertRaises(VimConnException
) as err
:
1986 self
.vimconn
._prepare
_disk
_for
_vminstance
(
1988 existing_vim_volumes
,
1991 block_device_mapping
,
1995 str(err
.exception
), "Timeout creating volumes for instance basicvm"
1997 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
1998 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
1999 mock_existing_vol_availability
.assert_called_once_with(
2000 1700, existing_vim_volumes
2002 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2003 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2004 mock_root_volumes
.assert_called_once_with(
2006 vm_av_zone
=["nova"],
2007 disk
={"size": 10, "image_id": image_id
},
2009 block_device_mapping
={},
2010 existing_vim_volumes
=[],
2013 mock_non_root_volumes
.assert_called_once_with(
2016 vm_av_zone
=["nova"],
2018 block_device_mapping
={},
2019 existing_vim_volumes
=[],
2023 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2024 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2025 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2026 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2027 def test_prepare_disk_for_vm_instance_empty_disk_list(
2029 mock_existing_vol_availability
,
2030 mock_created_vol_availability
,
2031 mock_non_root_volumes
,
2034 """Disk list is empty."""
2035 existing_vim_volumes
= []
2037 block_device_mapping
= {}
2038 vm_av_zone
= ["nova"]
2039 mock_created_vol_availability
.return_value
= 2
2040 mock_existing_vol_availability
.return_value
= 3
2042 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2044 existing_vim_volumes
,
2047 block_device_mapping
,
2050 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2051 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2052 mock_existing_vol_availability
.assert_called_once_with(2, existing_vim_volumes
)
2053 mock_root_volumes
.assert_not_called()
2054 mock_non_root_volumes
.assert_not_called()
2056 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2057 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2058 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2059 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2060 def test_prepare_disk_for_vm_instance_persistent_root_volume_error(
2062 mock_existing_vol_availability
,
2063 mock_created_vol_availability
,
2064 mock_non_root_volumes
,
2067 """Persistent root volumes preparation raises error."""
2068 existing_vim_volumes
= []
2070 vm_av_zone
= ["nova"]
2071 block_device_mapping
= {}
2073 mock_root_volumes
.side_effect
= Exception()
2074 mock_created_vol_availability
.return_value
= 10
2075 mock_existing_vol_availability
.return_value
= 15
2077 with self
.assertRaises(Exception):
2078 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2080 existing_vim_volumes
,
2083 block_device_mapping
,
2086 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2087 mock_created_vol_availability
.assert_not_called()
2088 mock_existing_vol_availability
.assert_not_called()
2089 mock_root_volumes
.assert_called_once_with(
2091 vm_av_zone
=["nova"],
2092 disk
={"size": 10, "image_id": image_id
},
2094 block_device_mapping
={},
2095 existing_vim_volumes
=[],
2098 mock_non_root_volumes
.assert_not_called()
2100 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2101 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2102 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2103 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2104 def test_prepare_disk_for_vm_instance_non_root_volume_error(
2106 mock_existing_vol_availability
,
2107 mock_created_vol_availability
,
2108 mock_non_root_volumes
,
2111 """Non-root volumes preparation raises error."""
2112 existing_vim_volumes
= []
2114 vm_av_zone
= ["nova"]
2115 block_device_mapping
= {}
2117 mock_root_volumes
.return_value
= root_vol_id
2118 mock_non_root_volumes
.side_effect
= Exception
2120 with self
.assertRaises(Exception):
2121 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2123 existing_vim_volumes
,
2126 block_device_mapping
,
2129 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2130 mock_created_vol_availability
.assert_not_called()
2131 mock_existing_vol_availability
.assert_not_called()
2132 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2133 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2134 mock_root_volumes
.assert_called_once_with(
2136 vm_av_zone
=["nova"],
2137 disk
={"size": 10, "image_id": image_id
},
2139 block_device_mapping
={},
2140 existing_vim_volumes
=[],
2143 mock_non_root_volumes
.assert_called_once_with(
2146 vm_av_zone
=["nova"],
2148 block_device_mapping
={},
2149 existing_vim_volumes
=[],
2153 def test_find_external_network_for_floating_ip_no_external_network(self
):
2154 """External network could not be found."""
2155 self
.vimconn
.neutron
.list_networks
.return_value
= {
2157 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": False}
2160 with self
.assertRaises(VimConnException
) as err
:
2161 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2164 "Cannot create floating_ip automatically since no external network is present",
2167 def test_find_external_network_for_floating_one_external_network(self
):
2168 """One external network has been found."""
2169 self
.vimconn
.neutron
.list_networks
.return_value
= {
2171 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True}
2174 expected_result
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
2175 result
= self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2176 self
.assertEqual(result
, expected_result
)
2178 def test_find_external_network_for_floating_neutron_raises_exception(self
):
2179 """Neutron list networks raises exception."""
2180 self
.vimconn
.neutron
.list_networks
.side_effect
= Exception
2181 with self
.assertRaises(Exception):
2182 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2184 def test_find_external_network_for_floating_several_external_network(self
):
2185 """Several exernal networks has been found."""
2186 self
.vimconn
.neutron
.list_networks
.return_value
= {
2188 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True},
2189 {"id": "608b73-y9cc-5a6a-a270-12cc4811bd4a", "router:external": True},
2192 with self
.assertRaises(VimConnException
) as err
:
2193 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2196 "Cannot create floating_ip automatically since multiple external networks are present",
2199 def test_neutron_create_float_ip(self
):
2200 """Floating ip creation is successful."""
2201 param
= {"net_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a"}
2203 self
.vimconn
.neutron
.create_floatingip
.return_value
= {
2204 "floatingip": {"id": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2206 expected_created_items
= {
2207 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True
2209 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2210 self
.assertEqual(created_items
, expected_created_items
)
2212 def test_neutron_create_float_ip_exception_occurred(self
):
2213 """Floating ip could not be created."""
2216 "floating_network_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a",
2217 "tenant_id": "308b73-19cc-8a6a-a270-02cc4811bd9a",
2221 self
.vimconn
.neutron
= CopyingMock()
2222 self
.vimconn
.neutron
.create_floatingip
.side_effect
= Exception(
2223 "Neutron floating ip create exception occurred."
2225 with self
.assertRaises(VimConnException
) as err
:
2226 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2227 self
.assertEqual(created_items
, {})
2230 "Exception: Cannot create new floating_ip Neutron floating ip create exception occurred.",
2233 @patch.object(vimconnector
, "_neutron_create_float_ip")
2234 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2235 def test_create_floating_ip_pool_id_available(
2236 self
, mock_find_ext_network
, mock_create_float_ip
2238 """Floating ip creation, ip pool is available."""
2239 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2243 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2244 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2247 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2248 mock_find_ext_network
.assert_not_called()
2249 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2251 @patch.object(vimconnector
, "_neutron_create_float_ip")
2252 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2253 def test_create_floating_ip_finding_pool_id(
2254 self
, mock_find_ext_network
, mock_create_float_ip
2256 """Floating ip creation, pool id need to be found."""
2257 floating_network
= {"floating_ip": True}
2259 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2262 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2263 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2266 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2267 mock_find_ext_network
.assert_called_once()
2268 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2270 @patch.object(vimconnector
, "_neutron_create_float_ip")
2271 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2272 def test_create_floating_ip_neutron_create_floating_ip_exception(
2273 self
, mock_find_ext_network
, mock_create_float_ip
2275 """Neutron creat floating ip raises error."""
2276 floating_network
= {"floating_ip": True}
2278 mock_create_float_ip
.side_effect
= VimConnException(
2279 "Can not create floating ip."
2281 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2284 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2285 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2289 with self
.assertRaises(VimConnException
) as err
:
2290 self
.vimconn
._create
_floating
_ip
(
2291 floating_network
, self
.server
, created_items
2293 self
.assertEqual(str(err
.exception
), "Can not create floating ip.")
2294 mock_find_ext_network
.assert_called_once()
2295 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2297 @patch.object(vimconnector
, "_neutron_create_float_ip")
2298 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2299 def test_create_floating_ip_can_not_find_pool_id(
2300 self
, mock_find_ext_network
, mock_create_float_ip
2302 """Floating ip creation, pool id could not be found."""
2303 floating_network
= {"floating_ip": True}
2305 mock_find_ext_network
.side_effect
= VimConnException(
2306 "Cannot create floating_ip automatically since no external network is present"
2308 with self
.assertRaises(VimConnException
) as err
:
2309 self
.vimconn
._create
_floating
_ip
(
2310 floating_network
, self
.server
, created_items
2314 "Cannot create floating_ip automatically since no external network is present",
2316 mock_find_ext_network
.assert_called_once()
2317 mock_create_float_ip
.assert_not_called()
2319 def test_find_floating_ip_get_free_floating_ip(self
):
2320 """Get free floating ips successfully."""
2323 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2324 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2325 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2328 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2329 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2331 result
= self
.vimconn
._find
_floating
_ip
(
2332 self
.server
, floating_ips
, floating_network
2334 self
.assertEqual(result
, expected_result
)
2336 def test_find_floating_ip_different_floating_network_id(self
):
2337 """Floating network id is different with floating_ip of floating network."""
2340 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2341 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2344 floating_network
= {"floating_ip": "508b73-t9cc-1a6a-a270-12cc4811bd4a"}
2346 result
= self
.vimconn
._find
_floating
_ip
(
2347 self
.server
, floating_ips
, floating_network
2349 self
.assertEqual(result
, None)
2351 def test_find_floating_ip_different_fip_tenant(self
):
2352 """Items in floating_ips has port_id, tenant_is is not same with server tenant id."""
2355 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2356 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2357 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2358 "tenant_id": self
.server
.id,
2361 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2362 mock_create_floating_ip
= CopyingMock()
2363 with patch
.object(vimconnector
, "_create_floating_ip", mock_create_floating_ip
):
2364 result
= self
.vimconn
._find
_floating
_ip
(
2365 self
.server
, floating_ips
, floating_network
2367 self
.assertEqual(result
, None)
2369 @patch("time.sleep")
2370 def test_assign_floating_ip(self
, mock_sleep
):
2371 """Assign floating ip successfully."""
2372 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2373 floating_network
= {"vim_id": floating_network_vim_id
}
2375 "port_id": floating_network_vim_id
,
2376 "floating_network_id": "p08b73-e9cc-5a6a-t270-82cc4811bd4a",
2377 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2378 "tenant_id": "k08b73-e9cc-5a6a-t270-82cc4811bd4a",
2380 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
2381 self
.vimconn
.neutron
.show_floatingip
.return_value
= fip
2382 expected_result
= fip
2384 result
= self
.vimconn
._assign
_floating
_ip
(free_floating_ip
, floating_network
)
2385 self
.assertEqual(result
, expected_result
)
2386 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2388 {"floatingip": {"port_id": floating_network_vim_id
}},
2390 mock_sleep
.assert_called_once_with(5)
2391 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
2393 @patch("time.sleep")
2394 def test_assign_floating_ip_update_floating_ip_exception(self
, mock_sleep
):
2395 """Neutron update floating ip raises exception."""
2396 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2397 floating_network
= {"vim_id": floating_network_vim_id
}
2398 self
.vimconn
.neutron
= CopyingMock()
2399 self
.vimconn
.neutron
.update_floatingip
.side_effect
= Exception(
2400 "Floating ip is not updated."
2403 with self
.assertRaises(Exception) as err
:
2404 result
= self
.vimconn
._assign
_floating
_ip
(
2405 free_floating_ip
, floating_network
2407 self
.assertEqual(result
, None)
2408 self
.assertEqual(str(err
.exception
), "Floating ip is not updated.")
2410 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2412 {"floatingip": {"port_id": floating_network_vim_id
}},
2414 mock_sleep
.assert_not_called()
2415 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2417 @patch("time.sleep")
2418 def test_assign_floating_ip_show_floating_ip_exception(self
, mock_sleep
):
2419 """Neutron show floating ip raises exception."""
2420 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2421 floating_network
= {"vim_id": floating_network_vim_id
}
2422 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
2423 self
.vimconn
.neutron
.show_floatingip
.side_effect
= Exception(
2424 "Floating ip could not be shown."
2427 with self
.assertRaises(Exception) as err
:
2428 result
= self
.vimconn
._assign
_floating
_ip
(
2429 free_floating_ip
, floating_network
2431 self
.assertEqual(result
, None)
2432 self
.assertEqual(str(err
.exception
), "Floating ip could not be shown.")
2433 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2435 {"floatingip": {"port_id": floating_network_vim_id
}},
2437 mock_sleep
.assert_called_once_with(5)
2438 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
2440 @patch("random.shuffle")
2441 @patch.object(vimconnector
, "_find_floating_ip")
2442 def test_get_free_floating_ip(self
, mock_find_floating_ip
, mock_shuffle
):
2443 """Get free floating ip successfully."""
2444 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2447 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2448 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2449 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2450 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2453 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
2454 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2455 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
2456 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2459 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
2460 "floatingips": floating_ips
2462 mock_find_floating_ip
.return_value
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2463 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2465 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2466 self
.assertEqual(result
, expected_result
)
2467 mock_shuffle
.assert_called_once_with(floating_ips
)
2468 mock_find_floating_ip
.assert_called_once_with(
2469 self
.server
, floating_ips
, floating_network
2472 @patch("random.shuffle")
2473 @patch.object(vimconnector
, "_find_floating_ip")
2474 def test_get_free_floating_ip_list_floating_ip_exception(
2475 self
, mock_find_floating_ip
, mock_shuffle
2477 """Neutron list floating IPs raises exception."""
2478 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2479 self
.vimconn
.neutron
= CopyingMock()
2480 self
.vimconn
.neutron
.list_floatingips
.side_effect
= Exception(
2481 "Floating ips could not be listed."
2483 with self
.assertRaises(Exception) as err
:
2484 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2485 self
.assertEqual(result
, None)
2486 self
.assertEqual(str(err
.exception
), "Floating ips could not be listed.")
2487 mock_shuffle
.assert_not_called()
2488 mock_find_floating_ip
.assert_not_called()
2490 @patch("random.shuffle")
2491 @patch.object(vimconnector
, "_find_floating_ip")
2492 def test_get_free_floating_ip_find_floating_ip_exception(
2493 self
, mock_find_floating_ip
, mock_shuffle
2495 """_find_floating_ip method raises exception."""
2496 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2499 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2500 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2501 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2502 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2505 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
2506 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2507 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
2508 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2511 self
.vimconn
.neutron
= CopyingMock()
2512 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
2513 "floatingips": floating_ips
2515 mock_find_floating_ip
.side_effect
= Exception(
2516 "Free floating ip could not be found."
2519 with self
.assertRaises(Exception) as err
:
2520 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2521 self
.assertEqual(result
, None)
2522 self
.assertEqual(str(err
.exception
), "Free floating ip could not be found.")
2523 mock_shuffle
.assert_called_once_with(floating_ips
)
2524 mock_find_floating_ip
.assert_called_once_with(
2525 self
.server
, floating_ips
, floating_network
2528 @patch.object(vimconnector
, "_create_floating_ip")
2529 @patch.object(vimconnector
, "_get_free_floating_ip")
2530 @patch.object(vimconnector
, "_assign_floating_ip")
2531 def test_prepare_external_network_for_vm_instance(
2533 mock_assign_floating_ip
,
2534 mock_get_free_floating_ip
,
2535 mock_create_floating_ip
,
2537 """Prepare external network successfully."""
2538 external_network
= [
2540 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2541 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2545 vm_start_time
= time_return_value
2546 mock_get_free_floating_ip
.side_effect
= ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
2547 mock_assign_floating_ip
.return_value
= {
2548 "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
2550 self
.vimconn
.neutron
= CopyingMock()
2551 self
.vimconn
.nova
= CopyingMock()
2552 self
.vimconn
.neutron
.show_floatingip
.return_value
= {
2553 "floatingip": {"port_id": ""}
2556 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2557 external_network
, self
.server
, created_items
, vm_start_time
2560 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2561 mock_get_free_floating_ip
.assert_called_once_with(
2564 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2565 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2568 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(
2569 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
2571 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2572 mock_create_floating_ip
.assert_not_called()
2573 mock_assign_floating_ip
.assert_called_once_with(
2574 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2576 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2577 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2582 @patch("time.sleep")
2583 @patch.object(vimconnector
, "_create_floating_ip")
2584 @patch.object(vimconnector
, "_get_free_floating_ip")
2585 @patch.object(vimconnector
, "_assign_floating_ip")
2586 def test_prepare_external_network_for_vm_instance_no_free_floating_ip(
2588 mock_assign_floating_ip
,
2589 mock_get_free_floating_ip
,
2590 mock_create_floating_ip
,
2594 """There is not any free floating ip."""
2595 floating_network
= {
2596 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2597 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2599 external_network
= [floating_network
]
2602 vm_start_time
= time_return_value
2603 mock_get_free_floating_ip
.return_value
= None
2604 mock_assign_floating_ip
.return_value
= {}
2605 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2606 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2608 with self
.assertRaises(KeyError):
2609 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2610 external_network
, self
.server
, created_items
, vm_start_time
2613 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2614 mock_get_free_floating_ip
.assert_called_with(
2617 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2618 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2621 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(None)
2622 mock_sleep
.assert_not_called()
2623 mock_time
.assert_not_called()
2624 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
2625 mock_create_floating_ip
.assert_called_with(
2626 floating_network
, self
.server
, created_items
2628 self
.assertEqual(mock_create_floating_ip
.call_count
, 4)
2629 mock_assign_floating_ip
.assert_not_called()
2630 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2633 @patch("time.sleep")
2634 @patch.object(vimconnector
, "_create_floating_ip")
2635 @patch.object(vimconnector
, "_get_free_floating_ip")
2636 @patch.object(vimconnector
, "_assign_floating_ip")
2637 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
2639 mock_assign_floating_ip
,
2640 mock_get_free_floating_ip
,
2641 mock_create_floating_ip
,
2645 """There is not any free floating ip, create_floating ip method raise exception
2646 exit_on_floating_ip_error set to False."""
2647 floating_network
= {
2648 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2649 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2650 "exit_on_floating_ip_error": False,
2652 external_network
= [floating_network
]
2655 vm_start_time
= time_return_value
2656 mock_get_free_floating_ip
.return_value
= None
2657 mock_assign_floating_ip
.return_value
= {}
2658 mock_create_floating_ip
.side_effect
= VimConnException(
2659 "Can not create floating ip."
2661 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2662 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2664 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2665 external_network
, self
.server
, created_items
, vm_start_time
2667 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2668 mock_get_free_floating_ip
.assert_called_with(
2671 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2672 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2673 "exit_on_floating_ip_error": False,
2676 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2677 mock_sleep
.assert_not_called()
2678 mock_time
.assert_not_called()
2679 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2680 mock_create_floating_ip
.assert_called_with(
2681 floating_network
, self
.server
, created_items
2683 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
2684 mock_assign_floating_ip
.assert_not_called()
2687 @patch("time.sleep")
2688 @patch.object(vimconnector
, "_create_floating_ip")
2689 @patch.object(vimconnector
, "_get_free_floating_ip")
2690 @patch.object(vimconnector
, "_assign_floating_ip")
2691 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
2693 mock_assign_floating_ip
,
2694 mock_get_free_floating_ip
,
2695 mock_create_floating_ip
,
2699 """There is not any free floating ip, create_floating ip method raise exception
2700 exit_on_floating_ip_error set to False."""
2701 floating_network
= {
2702 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2703 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2704 "exit_on_floating_ip_error": True,
2706 external_network
= [floating_network
]
2709 vm_start_time
= time_return_value
2710 mock_get_free_floating_ip
.return_value
= None
2711 mock_assign_floating_ip
.return_value
= {}
2712 mock_create_floating_ip
.side_effect
= VimConnException(
2713 "Can not create floating ip."
2715 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2716 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2717 with self
.assertRaises(VimConnException
):
2718 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2719 external_network
, self
.server
, created_items
, vm_start_time
2721 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2722 mock_get_free_floating_ip
.assert_called_with(
2725 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2726 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2727 "exit_on_floating_ip_error": True,
2730 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2731 mock_sleep
.assert_not_called()
2732 mock_time
.assert_not_called()
2733 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2734 mock_create_floating_ip
.assert_called_with(
2735 floating_network
, self
.server
, created_items
2737 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
2738 mock_assign_floating_ip
.assert_not_called()
2740 @patch.object(vimconnector
, "_create_floating_ip")
2741 @patch.object(vimconnector
, "_get_free_floating_ip")
2742 @patch.object(vimconnector
, "_assign_floating_ip")
2743 def test_prepare_external_network_for_vm_instance_fip_has_port_id(
2745 mock_assign_floating_ip
,
2746 mock_get_free_floating_ip
,
2747 mock_create_floating_ip
,
2749 """Neutron show floating ip return the fip with port_id and floating network vim_id
2750 is different from port_id."""
2751 floating_network
= {
2752 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2753 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2755 external_network
= [floating_network
]
2758 mock_get_free_floating_ip
.side_effect
= [
2759 "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
2760 "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
2761 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2763 mock_assign_floating_ip
.side_effect
= [
2764 {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2765 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2767 self
.vimconn
.neutron
= CopyingMock()
2768 self
.vimconn
.nova
= CopyingMock()
2769 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2770 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2771 {"floatingip": {"port_id": ""}},
2772 {"floatingip": {"port_id": ""}},
2774 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2775 external_network
, self
.server
, created_items
, vm_start_time
2777 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
2778 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2780 _call_mock_get_free_floating_ip
[0][0],
2787 _call_mock_get_free_floating_ip
[1][0],
2794 _call_mock_get_free_floating_ip
[2][0],
2800 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
2801 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2802 mock_create_floating_ip
.assert_not_called()
2803 self
.assertEqual(mock_assign_floating_ip
.call_count
, 2)
2804 _call_mock_assign_floating_ip
= mock_assign_floating_ip
.call_args_list
2806 _call_mock_assign_floating_ip
[0][0],
2807 ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
2810 _call_mock_assign_floating_ip
[1][0],
2811 ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
2815 @patch("time.sleep")
2816 @patch.object(vimconnector
, "_create_floating_ip")
2817 @patch.object(vimconnector
, "_get_free_floating_ip")
2818 @patch.object(vimconnector
, "_assign_floating_ip")
2819 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
2821 mock_assign_floating_ip
,
2822 mock_get_free_floating_ip
,
2823 mock_create_floating_ip
,
2827 """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
2828 VM status is in error."""
2829 floating_network
= {
2830 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2831 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2832 "exit_on_floating_ip_error": True,
2834 external_network
= [floating_network
]
2836 vm_start_time
= time_return_value
2838 mock_time
.side_effect
= [156570150, 156570800, 156571200]
2840 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2841 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2842 Exception("Floating ip could not be shown.")
2844 with self
.assertRaises(Exception) as err
:
2845 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2846 external_network
, self
.server
, created_items
, vm_start_time
2850 "Cannot create floating_ip: Exception Floating ip could not be shown.",
2853 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2854 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2856 _call_mock_get_free_floating_ip
[0][0],
2863 _call_mock_get_free_floating_ip
[1][0],
2870 _call_mock_get_free_floating_ip
[2][0],
2877 _call_mock_get_free_floating_ip
[3][0],
2884 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
2885 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2886 mock_create_floating_ip
.assert_not_called()
2887 mock_assign_floating_ip
.assert_not_called()
2888 mock_time
.assert_not_called()
2889 mock_sleep
.assert_not_called()
2892 @patch("time.sleep")
2893 @patch.object(vimconnector
, "_create_floating_ip")
2894 @patch.object(vimconnector
, "_get_free_floating_ip")
2895 @patch.object(vimconnector
, "_assign_floating_ip")
2896 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
2898 mock_assign_floating_ip
,
2899 mock_get_free_floating_ip
,
2900 mock_create_floating_ip
,
2904 """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
2905 VM status is in active."""
2906 floating_network
= {
2907 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2908 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2909 "exit_on_floating_ip_error": False,
2911 external_network
= [floating_network
]
2913 vm_start_time
= time_return_value
2915 mock_time
.side_effect
= [156570150, 156570800, 156571200]
2917 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ACTIVE"
2918 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2919 Exception("Floating ip could not be shown.")
2922 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2923 external_network
, self
.server
, created_items
, vm_start_time
2925 # self.assertEqual(str(err.exception), "Cannot create floating_ip")
2927 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2928 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2930 _call_mock_get_free_floating_ip
[0][0],
2937 _call_mock_get_free_floating_ip
[1][0],
2944 _call_mock_get_free_floating_ip
[2][0],
2951 _call_mock_get_free_floating_ip
[3][0],
2958 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
2959 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2960 mock_create_floating_ip
.assert_not_called()
2961 mock_assign_floating_ip
.assert_not_called()
2962 mock_time
.assert_not_called()
2963 mock_sleep
.assert_not_called()
2966 @patch("time.sleep")
2967 @patch.object(vimconnector
, "_create_floating_ip")
2968 @patch.object(vimconnector
, "_get_free_floating_ip")
2969 @patch.object(vimconnector
, "_assign_floating_ip")
2970 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
2972 mock_assign_floating_ip
,
2973 mock_get_free_floating_ip
,
2974 mock_create_floating_ip
,
2978 """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
2979 VM status is not ACTIVE or ERROR, server timeout happened."""
2980 floating_network
= {
2981 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2982 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2983 "exit_on_floating_ip_error": True,
2985 external_network
= [floating_network
]
2987 vm_start_time
= time_return_value
2988 mock_get_free_floating_ip
.side_effect
= None
2989 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
2990 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "OTHER"
2991 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2992 Exception("Floating ip could not be shown.")
2995 with self
.assertRaises(VimConnException
) as err
:
2996 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2997 external_network
, self
.server
, created_items
, vm_start_time
3001 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3004 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3005 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3007 _call_mock_get_free_floating_ip
[0][0],
3014 _call_mock_get_free_floating_ip
[1][0],
3021 _call_mock_get_free_floating_ip
[2][0],
3028 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3029 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3030 mock_create_floating_ip
.assert_not_called()
3031 mock_assign_floating_ip
.assert_not_called()
3032 self
.assertEqual(mock_time
.call_count
, 3)
3033 self
.assertEqual(mock_sleep
.call_count
, 2)
3036 @patch("time.sleep")
3037 @patch.object(vimconnector
, "_create_floating_ip")
3038 @patch.object(vimconnector
, "_get_free_floating_ip")
3039 @patch.object(vimconnector
, "_assign_floating_ip")
3040 def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3042 mock_assign_floating_ip
,
3043 mock_get_free_floating_ip
,
3044 mock_create_floating_ip
,
3048 """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3049 VM status is in ERROR."""
3050 floating_network
= {
3051 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3052 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3053 "exit_on_floating_ip_error": True,
3055 external_network
= [floating_network
]
3057 vm_start_time
= time_return_value
3059 mock_get_free_floating_ip
.side_effect
= [
3060 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3063 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3065 mock_assign_floating_ip
.side_effect
= [
3066 Exception("Floating ip could not be assigned.")
3069 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3070 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3071 {"floatingip": {"port_id": ""}}
3074 with self
.assertRaises(VimConnException
) as err
:
3075 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3076 external_network
, self
.server
, created_items
, vm_start_time
3080 "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3083 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3084 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3086 _call_mock_get_free_floating_ip
[0][0],
3093 _call_mock_get_free_floating_ip
[1][0],
3100 _call_mock_get_free_floating_ip
[2][0],
3107 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3108 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(
3109 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3111 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3112 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3113 mock_time
.assert_not_called()
3114 mock_sleep
.assert_not_called()
3115 mock_create_floating_ip
.assert_not_called()
3118 @patch("time.sleep")
3119 @patch.object(vimconnector
, "_create_floating_ip")
3120 @patch.object(vimconnector
, "_get_free_floating_ip")
3121 @patch.object(vimconnector
, "_assign_floating_ip")
3122 def test_prepare_external_network_for_vm_instance_empty_external_network_list(
3124 mock_assign_floating_ip
,
3125 mock_get_free_floating_ip
,
3126 mock_create_floating_ip
,
3130 """External network list is empty."""
3131 external_network
= []
3133 vm_start_time
= time_return_value
3135 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3136 external_network
, self
.server
, created_items
, vm_start_time
3138 mock_create_floating_ip
.assert_not_called()
3139 mock_time
.assert_not_called()
3140 mock_sleep
.assert_not_called()
3141 mock_assign_floating_ip
.assert_not_called()
3142 mock_get_free_floating_ip
.assert_not_called()
3143 self
.vimconn
.neutron
.show
.show_floatingip
.assert_not_called()
3144 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3146 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3147 def test_update_port_security_for_vm_instance(self
, mock_wait_for_vm
):
3148 """no_secured_ports has port and the port has allow-address-pairs."""
3149 no_secured_ports
= [(port2_id
, "allow-address-pairs")]
3151 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3153 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3155 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3157 {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
3160 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3161 def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
3162 self
, mock_wait_for_vm
3164 """no_secured_ports has port and the port does not have allow-address-pairs."""
3165 no_secured_ports
= [(port2_id
, "something")]
3167 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3169 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3171 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3173 {"port": {"port_security_enabled": False, "security_groups": None}},
3176 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3177 def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
3178 self
, mock_wait_for_vm
3180 """__wait_for_vm raises timeout exception."""
3181 no_secured_ports
= [(port2_id
, "something")]
3183 mock_wait_for_vm
.side_effect
= VimConnException("Timeout waiting for instance.")
3185 with self
.assertRaises(VimConnException
) as err
:
3186 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3187 no_secured_ports
, self
.server
3189 self
.assertEqual(str(err
.exception
), "Timeout waiting for instance.")
3191 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3193 self
.vimconn
.neutron
.update_port
.assert_not_called()
3195 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3196 def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
3197 self
, mock_wait_for_vm
3199 """neutron_update_port method raises exception."""
3200 no_secured_ports
= [(port2_id
, "something")]
3202 self
.vimconn
.neutron
.update_port
.side_effect
= Exception(
3203 "Port security could not be updated."
3206 with self
.assertRaises(VimConnException
) as err
:
3207 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3208 no_secured_ports
, self
.server
3212 "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
3214 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3216 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3218 {"port": {"port_security_enabled": False, "security_groups": None}},
3221 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3222 def test_update_port_security_for_vm_instance_empty_port_list(
3223 self
, mock_wait_for_vm
3225 """no_secured_ports list does not have any ports."""
3226 no_secured_ports
= []
3228 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3230 mock_wait_for_vm
.assert_not_called()
3232 self
.vimconn
.neutron
.update_port
.assert_not_called()
3235 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3236 @patch.object(vimconnector
, "_reload_connection")
3237 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3238 @patch.object(vimconnector
, "_create_user_data")
3239 @patch.object(vimconnector
, "_get_vm_availability_zone")
3240 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3241 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3242 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3243 @patch.object(vimconnector
, "delete_vminstance")
3244 @patch.object(vimconnector
, "_format_exception")
3245 def test_new_vm_instance(
3247 mock_format_exception
,
3248 mock_delete_vm_instance
,
3249 mock_prepare_external_network
,
3250 mock_update_port_security
,
3251 mock_prepare_disk_for_vm_instance
,
3252 mock_get_vm_availability_zone
,
3253 mock_create_user_data
,
3254 mock_prepare_network_for_vm_instance
,
3255 mock_reload_connection
,
3256 mock_remove_keep_flag_from_persistent_volumes
,
3259 """New VM instance creation is successful."""
3261 mock_create_user_data
.return_value
= True, "userdata"
3263 mock_get_vm_availability_zone
.return_value
= "nova"
3265 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3267 mock_time
.return_value
= time_return_value
3269 expected_result
= self
.server
.id, {}
3271 result
= self
.vimconn
.new_vminstance(
3277 affinity_group_list
,
3281 availability_zone_index
,
3282 availability_zone_list
,
3284 self
.assertEqual(result
, expected_result
)
3286 mock_reload_connection
.assert_called_once()
3287 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3292 external_network
=[],
3293 no_secured_ports
=[],
3295 mock_create_user_data
.assert_called_once_with(cloud_config
)
3296 mock_get_vm_availability_zone
.assert_called_once_with(
3297 availability_zone_index
, availability_zone_list
3299 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3301 existing_vim_volumes
=[],
3304 block_device_mapping
={},
3305 disk_list
=disk_list2
,
3307 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3312 security_groups
="default",
3313 availability_zone
="nova",
3314 key_name
="my_keypair",
3315 userdata
="userdata",
3317 block_device_mapping
={},
3320 mock_time
.assert_called_once()
3321 mock_update_port_security
.assert_called_once_with([], self
.server
)
3322 mock_prepare_external_network
.assert_called_once_with(
3323 external_network
=[],
3326 vm_start_time
=time_return_value
,
3328 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
3329 mock_delete_vm_instance
.assert_not_called()
3330 mock_format_exception
.assert_not_called()
3333 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3334 @patch.object(vimconnector
, "_reload_connection")
3335 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3336 @patch.object(vimconnector
, "_create_user_data")
3337 @patch.object(vimconnector
, "_get_vm_availability_zone")
3338 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3339 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3340 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3341 @patch.object(vimconnector
, "delete_vminstance")
3342 @patch.object(vimconnector
, "_format_exception")
3343 def test_new_vm_instance_create_user_data_fails(
3345 mock_format_exception
,
3346 mock_delete_vm_instance
,
3347 mock_prepare_external_network
,
3348 mock_update_port_security
,
3349 mock_prepare_disk_for_vm_instance
,
3350 mock_get_vm_availability_zone
,
3351 mock_create_user_data
,
3352 mock_prepare_network_for_vm_instance
,
3353 mock_reload_connection
,
3354 mock_remove_keep_flag_from_persistent_volumes
,
3357 """New VM instance creation failed because of user data creation failure."""
3359 mock_create_user_data
.side_effect
= Exception(
3360 "User data could not be retrieved."
3363 mock_get_vm_availability_zone
.return_value
= "nova"
3365 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3367 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3369 mock_time
.return_value
= time_return_value
3371 self
.vimconn
.new_vminstance(
3377 affinity_group_list
,
3381 availability_zone_index
,
3382 availability_zone_list
,
3385 mock_reload_connection
.assert_called_once()
3386 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3391 external_network
=[],
3392 no_secured_ports
=[],
3394 mock_create_user_data
.assert_called_once_with(cloud_config
)
3395 mock_get_vm_availability_zone
.assert_not_called()
3396 mock_prepare_disk_for_vm_instance
.assert_not_called()
3397 self
.vimconn
.nova
.servers
.create
.assert_not_called()
3398 mock_time
.assert_not_called()
3399 mock_update_port_security
.assert_not_called()
3400 mock_prepare_external_network
.assert_not_called()
3401 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3402 mock_delete_vm_instance
.assert_called_once_with(None, {})
3403 mock_format_exception
.assert_called_once()
3404 arg
= mock_format_exception
.call_args
[0][0]
3405 self
.assertEqual(str(arg
), "User data could not be retrieved.")
3408 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3409 @patch.object(vimconnector
, "_reload_connection")
3410 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3411 @patch.object(vimconnector
, "_create_user_data")
3412 @patch.object(vimconnector
, "_get_vm_availability_zone")
3413 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3414 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3415 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3416 @patch.object(vimconnector
, "delete_vminstance")
3417 @patch.object(vimconnector
, "_format_exception")
3418 def test_new_vm_instance_external_network_exception(
3420 mock_format_exception
,
3421 mock_delete_vm_instance
,
3422 mock_prepare_external_network
,
3423 mock_update_port_security
,
3424 mock_prepare_disk_for_vm_instance
,
3425 mock_get_vm_availability_zone
,
3426 mock_create_user_data
,
3427 mock_prepare_network_for_vm_instance
,
3428 mock_reload_connection
,
3429 mock_remove_keep_flag_from_persistent_volumes
,
3432 """New VM instance creation, external network connection has failed as floating
3433 ip could not be created."""
3435 mock_create_user_data
.return_value
= True, "userdata"
3437 mock_get_vm_availability_zone
.return_value
= "nova"
3439 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3441 mock_time
.return_value
= time_return_value
3443 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3445 mock_prepare_external_network
.side_effect
= VimConnException(
3446 "Can not create floating ip."
3449 self
.vimconn
.new_vminstance(
3455 affinity_group_list
,
3459 availability_zone_index
,
3460 availability_zone_list
,
3463 mock_reload_connection
.assert_called_once()
3464 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3469 external_network
=[],
3470 no_secured_ports
=[],
3472 mock_create_user_data
.assert_called_once_with(cloud_config
)
3473 mock_get_vm_availability_zone
.assert_called_once_with(
3474 availability_zone_index
, availability_zone_list
3476 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3478 existing_vim_volumes
=[],
3481 block_device_mapping
={},
3482 disk_list
=disk_list2
,
3484 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3489 security_groups
="default",
3490 availability_zone
="nova",
3491 key_name
="my_keypair",
3492 userdata
="userdata",
3494 block_device_mapping
={},
3497 mock_time
.assert_called_once()
3498 mock_update_port_security
.assert_called_once_with([], self
.server
)
3499 mock_prepare_external_network
.assert_called_once_with(
3500 external_network
=[],
3503 vm_start_time
=time_return_value
,
3505 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3506 mock_delete_vm_instance
.assert_called_once_with(self
.server
.id, {})
3507 mock_format_exception
.assert_called_once()
3508 arg
= mock_format_exception
.call_args
[0][0]
3509 self
.assertEqual(str(arg
), "Can not create floating ip.")
3512 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3513 @patch.object(vimconnector
, "_reload_connection")
3514 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3515 @patch.object(vimconnector
, "_create_user_data")
3516 @patch.object(vimconnector
, "_get_vm_availability_zone")
3517 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3518 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3519 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3520 @patch.object(vimconnector
, "delete_vminstance")
3521 @patch.object(vimconnector
, "_format_exception")
3522 def test_new_vm_instance_with_affinity_group(
3524 mock_format_exception
,
3525 mock_delete_vm_instance
,
3526 mock_prepare_external_network
,
3527 mock_update_port_security
,
3528 mock_prepare_disk_for_vm_instance
,
3529 mock_get_vm_availability_zone
,
3530 mock_create_user_data
,
3531 mock_prepare_network_for_vm_instance
,
3532 mock_reload_connection
,
3533 mock_remove_keep_flag_from_persistent_volumes
,
3536 """New VM creation with affinity group."""
3537 affinity_group_list
= [
3538 {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
3540 mock_create_user_data
.return_value
= True, "userdata"
3541 mock_get_vm_availability_zone
.return_value
= "nova"
3542 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3543 mock_time
.return_value
= time_return_value
3544 expected_result
= self
.server
.id, {}
3546 result
= self
.vimconn
.new_vminstance(
3552 affinity_group_list
,
3556 availability_zone_index
,
3557 availability_zone_list
,
3559 self
.assertEqual(result
, expected_result
)
3561 mock_reload_connection
.assert_called_once()
3562 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3567 external_network
=[],
3568 no_secured_ports
=[],
3570 mock_create_user_data
.assert_called_once_with(cloud_config
)
3571 mock_get_vm_availability_zone
.assert_called_once_with(
3572 availability_zone_index
, availability_zone_list
3574 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3576 existing_vim_volumes
=[],
3579 block_device_mapping
={},
3580 disk_list
=disk_list2
,
3582 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3587 security_groups
="default",
3588 availability_zone
="nova",
3589 key_name
="my_keypair",
3590 userdata
="userdata",
3592 block_device_mapping
={},
3593 scheduler_hints
={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
3595 mock_time
.assert_called_once()
3596 mock_update_port_security
.assert_called_once_with([], self
.server
)
3597 mock_prepare_external_network
.assert_called_once_with(
3598 external_network
=[],
3601 vm_start_time
=time_return_value
,
3603 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
3604 mock_delete_vm_instance
.assert_not_called()
3605 mock_format_exception
.assert_not_called()
3608 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3609 @patch.object(vimconnector
, "_reload_connection")
3610 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3611 @patch.object(vimconnector
, "_create_user_data")
3612 @patch.object(vimconnector
, "_get_vm_availability_zone")
3613 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3614 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3615 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3616 @patch.object(vimconnector
, "delete_vminstance")
3617 @patch.object(vimconnector
, "_format_exception")
3618 def test_new_vm_instance_nova_server_create_failed(
3620 mock_format_exception
,
3621 mock_delete_vm_instance
,
3622 mock_prepare_external_network
,
3623 mock_update_port_security
,
3624 mock_prepare_disk_for_vm_instance
,
3625 mock_get_vm_availability_zone
,
3626 mock_create_user_data
,
3627 mock_prepare_network_for_vm_instance
,
3628 mock_reload_connection
,
3629 mock_remove_keep_flag_from_persistent_volumes
,
3632 """New VM(server) creation failed."""
3634 mock_create_user_data
.return_value
= True, "userdata"
3636 mock_get_vm_availability_zone
.return_value
= "nova"
3638 self
.vimconn
.nova
.servers
.create
.side_effect
= Exception(
3639 "Server could not be created."
3642 mock_time
.return_value
= time_return_value
3644 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3646 self
.vimconn
.new_vminstance(
3652 affinity_group_list
,
3656 availability_zone_index
,
3657 availability_zone_list
,
3660 mock_reload_connection
.assert_called_once()
3661 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3666 external_network
=[],
3667 no_secured_ports
=[],
3669 mock_create_user_data
.assert_called_once_with(cloud_config
)
3670 mock_get_vm_availability_zone
.assert_called_once_with(
3671 availability_zone_index
, availability_zone_list
3673 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3675 existing_vim_volumes
=[],
3678 block_device_mapping
={},
3679 disk_list
=disk_list2
,
3682 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3687 security_groups
="default",
3688 availability_zone
="nova",
3689 key_name
="my_keypair",
3690 userdata
="userdata",
3692 block_device_mapping
={},
3695 mock_time
.assert_not_called()
3696 mock_update_port_security
.assert_not_called()
3697 mock_prepare_external_network
.assert_not_called()
3698 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3699 mock_delete_vm_instance
.assert_called_once_with(None, {})
3700 mock_format_exception
.assert_called_once()
3701 arg
= mock_format_exception
.call_args
[0][0]
3702 self
.assertEqual(str(arg
), "Server could not be created.")
3705 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3706 @patch.object(vimconnector
, "_reload_connection")
3707 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3708 @patch.object(vimconnector
, "_create_user_data")
3709 @patch.object(vimconnector
, "_get_vm_availability_zone")
3710 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3711 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3712 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3713 @patch.object(vimconnector
, "delete_vminstance")
3714 @patch.object(vimconnector
, "_format_exception")
3715 def test_new_vm_instance_connection_exception(
3717 mock_format_exception
,
3718 mock_delete_vm_instance
,
3719 mock_prepare_external_network
,
3720 mock_update_port_security
,
3721 mock_prepare_disk_for_vm_instance
,
3722 mock_get_vm_availability_zone
,
3723 mock_create_user_data
,
3724 mock_prepare_network_for_vm_instance
,
3725 mock_reload_connection
,
3726 mock_remove_keep_flag_from_persistent_volumes
,
3729 """Connection to Cloud API has failed."""
3730 mock_reload_connection
.side_effect
= Exception("Can not connect to Cloud APIs.")
3731 mock_create_user_data
.return_value
= True, "userdata"
3732 mock_get_vm_availability_zone
.return_value
= "nova"
3733 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3734 mock_time
.return_value
= time_return_value
3735 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3737 self
.vimconn
.new_vminstance(
3743 affinity_group_list
,
3747 availability_zone_index
,
3748 availability_zone_list
,
3750 mock_format_exception
.assert_called_once()
3751 arg
= mock_format_exception
.call_args
[0][0]
3752 self
.assertEqual(str(arg
), "Can not connect to Cloud APIs.")
3753 mock_reload_connection
.assert_called_once()
3754 mock_prepare_network_for_vm_instance
.assert_not_called()
3755 mock_create_user_data
.assert_not_called()
3756 mock_get_vm_availability_zone
.assert_not_called()
3757 mock_prepare_disk_for_vm_instance
.assert_not_called()
3758 self
.vimconn
.nova
.servers
.create
.assert_not_called()
3759 mock_time
.assert_not_called()
3760 mock_update_port_security
.assert_not_called()
3761 mock_prepare_external_network
.assert_not_called()
3762 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3763 mock_delete_vm_instance
.assert_called_once_with(None, {})
3765 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3766 def test_delete_vm_ports_attached_to_network_empty_created_items(
3767 self
, mock_delete_ports_by_id_wth_neutron
3769 """Created_items is emtpty."""
3771 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3772 self
.vimconn
.neutron
.list_ports
.assert_not_called()
3773 self
.vimconn
.neutron
.delete_port
.assert_not_called()
3774 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3776 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3777 def test_delete_vm_ports_attached_to_network(
3778 self
, mock_delete_ports_by_id_wth_neutron
3781 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
3782 f
"volume:{volume_id2}": True,
3783 f
"volume:{volume_id}": True,
3784 f
"port:{port_id}": True,
3786 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3787 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3788 self
.vimconn
.logger
.error
.assert_not_called()
3790 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3791 def test_delete_vm_ports_attached_to_network_wthout_port(
3792 self
, mock_delete_ports_by_id_wth_neutron
3794 """Created_items does not have port."""
3796 f
"floating_ip:{floating_network_vim_id}": True,
3797 f
"volume:{volume_id2}": True,
3798 f
"volume:{volume_id}": True,
3800 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3801 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3802 self
.vimconn
.logger
.error
.assert_not_called()
3804 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3805 def test_delete_vm_ports_attached_to_network_delete_port_raise_vimconnexception(
3806 self
, mock_delete_ports_by_id_wth_neutron
3808 """_delete_ports_by_id_wth_neutron raises vimconnexception."""
3809 created_items
= deepcopy(created_items_all_true
)
3810 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
3811 "Can not delete port"
3813 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3814 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3815 self
.vimconn
.logger
.error
.assert_called_once_with(
3816 "Error deleting port: VimConnException: Can not delete port"
3819 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3820 def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
3821 self
, mock_delete_ports_by_id_wth_neutron
3823 """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
3824 created_items
= deepcopy(created_items_all_true
)
3825 mock_delete_ports_by_id_wth_neutron
.side_effect
= nvExceptions
.ClientException(
3826 "Connection aborted."
3828 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3829 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3830 self
.vimconn
.logger
.error
.assert_called_once_with(
3831 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
3834 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3835 def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
3836 self
, mock_delete_ports_by_id_wth_neutron
3838 """port item is invalid."""
3840 f
"floating_ip:{floating_network_vim_id}": True,
3841 f
"volume:{volume_id2}": True,
3842 f
"volume:{volume_id}": True,
3843 f
"port:{port_id}:": True,
3845 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
3846 "Port is not valid."
3848 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3849 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}:")
3850 self
.vimconn
.logger
.error
.assert_called_once_with(
3851 "Error deleting port: VimConnException: Port is not valid."
3854 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3855 def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
3856 self
, mock_delete_ports_by_id_wth_neutron
3858 """port is already deleted."""
3860 f
"floating_ip:{floating_network_vim_id}": True,
3861 f
"volume:{volume_id2}": True,
3862 f
"volume:{volume_id}": None,
3863 f
"port:{port_id}": None,
3865 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3866 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3867 self
.vimconn
.logger
.error
.assert_not_called()
3869 def test_delete_floating_ip_by_id(self
):
3871 f
"floating_ip:{floating_network_vim_id}": True,
3872 f
"port:{port_id}": True,
3874 expected_created_items
= {
3875 f
"floating_ip:{floating_network_vim_id}": None,
3876 f
"port:{port_id}": True,
3878 k_id
= floating_network_vim_id
3879 k
= f
"floating_ip:{floating_network_vim_id}"
3880 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3881 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3882 self
.assertEqual(created_items
, expected_created_items
)
3884 def test_delete_floating_ip_by_id_floating_ip_already_deleted(self
):
3885 """floating ip is already deleted."""
3887 f
"floating_ip:{floating_network_vim_id}": None,
3888 f
"port:{port_id}": True,
3890 k_id
= floating_network_vim_id
3891 k
= f
"floating_ip:{floating_network_vim_id}"
3892 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3893 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3897 f
"floating_ip:{floating_network_vim_id}": None,
3898 f
"port:{port_id}": True,
3902 def test_delete_floating_ip_by_id__delete_floating_ip_raises_client_exception__operation_is_successful(
3905 """netron delete floating ip raises nvExceptions.ClientException."""
3907 f
"floating_ip:{floating_network_vim_id}": True,
3908 f
"port:{port_id}": True,
3910 k_id
= floating_network_vim_id
3911 k
= f
"floating_ip:{floating_network_vim_id}"
3912 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= (
3913 nvExceptions
.ClientException("Client exception occurred.")
3915 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3916 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3920 f
"floating_ip:{floating_network_vim_id}": True,
3921 f
"port:{port_id}": True,
3924 self
.vimconn
.logger
.error
.assert_called_once_with(
3925 "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occurred.)"
3928 def test_delete_floating_ip_by_id__delete_floating_ip_raises_connection_error__operation_fails(
3931 """netron delete floating ip raises nvExceptions.ClientException."""
3933 f
"floating_ip:{floating_network_vim_id}": True,
3934 f
"port:{port_id}": True,
3936 k_id
= floating_network_vim_id
3937 k
= f
"floating_ip:{floating_network_vim_id}"
3938 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= ConnectionError(
3939 "Connection exception occurred."
3941 with self
.assertRaises(VimConnConnectionException
):
3942 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3943 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3947 f
"floating_ip:{floating_network_vim_id}": True,
3948 f
"port:{port_id}": True,
3951 self
.vimconn
.logger
.error
.assert_called_once_with(
3952 "Error deleting floating ip: ConnectionError: Connection exception occurred."
3955 def test_delete_floating_ip_by_id_floating_ip_raises_vimconn_not_found_exception__operation_is_successful(
3958 """netron delete floating ip raises VimConnNotFoundException."""
3960 f
"floating_ip:{floating_network_vim_id}": True,
3961 f
"port:{port_id}": True,
3963 k_id
= floating_network_vim_id
3964 k
= f
"floating_ip:{floating_network_vim_id}"
3965 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= VimConnNotFoundException(
3966 "Port id could not found."
3968 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3969 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3973 f
"floating_ip:{floating_network_vim_id}": True,
3974 f
"port:{port_id}": True,
3977 self
.vimconn
.logger
.error
.assert_called_once_with(
3978 "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
3981 def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self
):
3982 """invalid floating ip item."""
3984 f
"floating_ip:{floating_network_vim_id}": True,
3985 f
"port:{port_id}": True,
3987 expected_created_items
= {
3988 f
"floating_ip:{floating_network_vim_id}::": None,
3989 f
"floating_ip:{floating_network_vim_id}": True,
3990 f
"port:{port_id}": True,
3992 k_id
= floating_network_vim_id
3993 k
= f
"floating_ip:{floating_network_vim_id}::"
3994 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3995 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3996 self
.assertEqual(created_items
, expected_created_items
)
3998 def test_delete_volumes_by_id_with_cinder_volume_status_available(self
):
3999 """volume status is available."""
4001 f
"floating_ip:{floating_network_vim_id}": True,
4002 f
"volume:{volume_id2}": True,
4003 f
"volume:{volume_id}": True,
4004 f
"port:{port_id}": None,
4006 expected_created_items
= {
4007 f
"floating_ip:{floating_network_vim_id}": True,
4008 f
"volume:{volume_id2}": True,
4009 f
"volume:{volume_id}": None,
4010 f
"port:{port_id}": None,
4012 volumes_to_hold
= []
4013 k
= f
"volume:{volume_id}"
4015 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4016 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4017 k
, k_id
, volumes_to_hold
, created_items
4019 self
.assertEqual(result
, None)
4020 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4021 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4022 self
.vimconn
.logger
.error
.assert_not_called()
4023 self
.assertEqual(created_items
, expected_created_items
)
4025 def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self
):
4026 """volume is already deleted."""
4028 f
"floating_ip:{floating_network_vim_id}": True,
4029 f
"volume:{volume_id2}": True,
4030 f
"volume:{volume_id}": None,
4031 f
"port:{port_id}": None,
4033 expected_created_items
= {
4034 f
"floating_ip:{floating_network_vim_id}": True,
4035 f
"volume:{volume_id2}": True,
4036 f
"volume:{volume_id}": None,
4037 f
"port:{port_id}": None,
4039 volumes_to_hold
= []
4040 k
= f
"volume:{volume_id}"
4042 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4043 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4044 k
, k_id
, volumes_to_hold
, created_items
4046 self
.assertEqual(result
, None)
4047 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4048 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4049 self
.vimconn
.logger
.error
.assert_not_called()
4050 self
.assertEqual(created_items
, expected_created_items
)
4052 def test_delete_shared_volumes(self
):
4053 """cinder delete shared volumes"""
4054 shared_volume_vim_id
= volume_id4
4055 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4056 self
.vimconn
.delete_shared_volumes(shared_volume_vim_id
)
4057 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(shared_volume_vim_id
)
4058 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(shared_volume_vim_id
)
4059 self
.vimconn
.logger
.error
.assert_not_called()
4061 def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self
):
4062 """cinder get volume raises exception."""
4064 f
"floating_ip:{floating_network_vim_id}": True,
4065 f
"volume:{volume_id2}": True,
4066 f
"volume:{volume_id}": True,
4067 f
"port:{port_id}": None,
4069 expected_created_items
= {
4070 f
"floating_ip:{floating_network_vim_id}": True,
4071 f
"volume:{volume_id2}": True,
4072 f
"volume:{volume_id}": True,
4073 f
"port:{port_id}": None,
4075 volumes_to_hold
= []
4076 k
= f
"volume:{volume_id}"
4078 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception(
4079 "Can not get volume status."
4081 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4082 k
, k_id
, volumes_to_hold
, created_items
4084 self
.assertEqual(result
, None)
4085 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4086 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4087 self
.vimconn
.logger
.error
.assert_called_once_with(
4088 "Error deleting volume: Exception: Can not get volume status."
4090 self
.assertEqual(created_items
, expected_created_items
)
4092 def test_delete_volumes_by_id_with_cinder__delete_volume_raise_client_exception__exception_is_not_raised(
4095 """cinder delete volume raises exception."""
4097 f
"floating_ip:{floating_network_vim_id}": True,
4098 f
"volume:{volume_id2}": True,
4099 f
"volume:{volume_id}": True,
4100 f
"port:{port_id}": None,
4102 expected_created_items
= {
4103 f
"floating_ip:{floating_network_vim_id}": True,
4104 f
"volume:{volume_id2}": True,
4105 f
"volume:{volume_id}": True,
4106 f
"port:{port_id}": None,
4108 volumes_to_hold
= []
4109 k
= f
"volume:{volume_id}"
4111 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4112 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= cExceptions
.ClientException(
4113 403, "Connection aborted."
4115 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4116 k
, k_id
, volumes_to_hold
, created_items
4118 self
.assertEqual(result
, None)
4119 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4120 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4121 self
.vimconn
.logger
.error
.assert_called_once_with(
4122 "Error deleting volume: ClientException: Connection aborted. (HTTP 403)"
4124 self
.assertEqual(created_items
, expected_created_items
)
4126 def test_delete_volumes_by_id_with_cinder__delete_volume_raise_connection_exception__exception_is_raised(
4129 """cinder delete volume raises exception."""
4131 f
"floating_ip:{floating_network_vim_id}": True,
4132 f
"volume:{volume_id2}": True,
4133 f
"volume:{volume_id}": True,
4134 f
"port:{port_id}": None,
4136 expected_created_items
= {
4137 f
"floating_ip:{floating_network_vim_id}": True,
4138 f
"volume:{volume_id2}": True,
4139 f
"volume:{volume_id}": True,
4140 f
"port:{port_id}": None,
4142 volumes_to_hold
= []
4143 k
= f
"volume:{volume_id}"
4145 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4146 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= cExceptions
.ConnectionError(
4147 "Connection failed."
4149 with self
.assertRaises(VimConnConnectionException
):
4150 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4151 k
, k_id
, volumes_to_hold
, created_items
4153 self
.assertEqual(result
, None)
4154 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4155 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4156 self
.vimconn
.logger
.error
.assert_called_once_with(
4157 "Error deleting volume: ConnectionError: Connection failed."
4159 self
.assertEqual(created_items
, expected_created_items
)
4161 def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self
):
4162 """volume_to_hold has item."""
4164 f
"floating_ip:{floating_network_vim_id}": True,
4165 f
"volume:{volume_id2}": True,
4166 f
"volume:{volume_id}": True,
4167 f
"port:{port_id}": None,
4169 expected_created_items
= {
4170 f
"floating_ip:{floating_network_vim_id}": True,
4171 f
"volume:{volume_id2}": True,
4172 f
"volume:{volume_id}": True,
4173 f
"port:{port_id}": None,
4175 volumes_to_hold
= [volume_id
]
4176 k
= f
"volume:{volume_id}"
4178 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4179 k
, k_id
, volumes_to_hold
, created_items
4181 self
.assertEqual(result
, False)
4182 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
4183 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4184 self
.vimconn
.logger
.error
.assert_not_called()
4185 self
.assertEqual(created_items
, expected_created_items
)
4187 def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self
):
4188 """volume status is not available."""
4190 f
"floating_ip:{floating_network_vim_id}": True,
4191 f
"volume:{volume_id2}": True,
4192 f
"volume:{volume_id}": True,
4193 f
"port:{port_id}": None,
4195 expected_created_items
= {
4196 f
"floating_ip:{floating_network_vim_id}": True,
4197 f
"volume:{volume_id2}": True,
4198 f
"volume:{volume_id}": True,
4199 f
"port:{port_id}": None,
4201 volumes_to_hold
= []
4202 k
= f
"volume:{volume_id}"
4204 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "unavailable"
4205 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4206 k
, k_id
, volumes_to_hold
, created_items
4208 self
.assertEqual(result
, True)
4209 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4210 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4211 self
.vimconn
.logger
.error
.assert_not_called()
4212 self
.assertEqual(created_items
, expected_created_items
)
4214 def test_delete_ports_by_id_by_neutron(self
):
4215 """neutron delete ports."""
4217 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4218 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4219 self
.vimconn
.logger
.error
.assert_not_called()
4221 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
4222 """neutron delete port raises exception."""
4224 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
4225 "Connection aborted."
4227 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4228 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4229 self
.vimconn
.logger
.error
.assert_called_once_with(
4230 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4233 def test_get_item_name_id(self
):
4234 """Get name and id successfully."""
4235 k
= f
"some:{port_id}"
4236 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4237 self
.assertEqual(result
, ("some", f
"{port_id}"))
4239 def test_get_item_name_id_wthout_semicolon(self
):
4240 """Does not have seperator."""
4241 k
= f
"some{port_id}"
4242 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4243 self
.assertEqual(result
, (f
"some{port_id}", ""))
4245 def test_get_item_name_id_empty_string(self
):
4248 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4249 self
.assertEqual(result
, ("", ""))
4251 def test_get_item_name_id_k_is_none(self
):
4254 with self
.assertRaises(AttributeError):
4255 self
.vimconn
._get
_item
_name
_id
(k
)
4257 @patch.object(vimconnector
, "_get_item_name_id")
4258 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4259 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4260 def test_delete_created_items(
4262 mock_delete_floating_ip_by_id
,
4263 mock_delete_volumes_by_id_wth_cinder
,
4264 mock_get_item_name_id
,
4266 """Created items has floating ip and volume."""
4268 f
"floating_ip:{floating_network_vim_id}": True,
4269 f
"volume:{volume_id}": True,
4270 f
"port:{port_id}": None,
4272 mock_get_item_name_id
.side_effect
= [
4273 ("floating_ip", f
"{floating_network_vim_id}"),
4274 ("volume", f
"{volume_id}"),
4276 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4277 volumes_to_hold
= []
4278 keep_waiting
= False
4279 result
= self
.vimconn
._delete
_created
_items
(
4280 created_items
, volumes_to_hold
, keep_waiting
4282 self
.assertEqual(result
, True)
4283 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4284 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4285 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4287 mock_delete_floating_ip_by_id
.assert_called_once_with(
4288 f
"floating_ip:{floating_network_vim_id}",
4289 f
"{floating_network_vim_id}",
4292 self
.vimconn
.logger
.error
.assert_not_called()
4294 @patch.object(vimconnector
, "_get_item_name_id")
4295 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4296 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4297 def test_delete_created_items_wth_volumes_to_hold(
4299 mock_delete_floating_ip_by_id
,
4300 mock_delete_volumes_by_id_wth_cinder
,
4301 mock_get_item_name_id
,
4303 """Created items has floating ip and volume and volumes_to_hold has items."""
4305 f
"floating_ip:{floating_network_vim_id}": True,
4306 f
"volume:{volume_id}": True,
4307 f
"port:{port_id}": None,
4309 mock_get_item_name_id
.side_effect
= [
4310 ("floating_ip", f
"{floating_network_vim_id}"),
4311 ("volume", f
"{volume_id}"),
4313 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4314 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4315 keep_waiting
= False
4316 result
= self
.vimconn
._delete
_created
_items
(
4317 created_items
, volumes_to_hold
, keep_waiting
4319 self
.assertEqual(result
, True)
4320 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4321 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4322 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4324 mock_delete_floating_ip_by_id
.assert_called_once_with(
4325 f
"floating_ip:{floating_network_vim_id}",
4326 f
"{floating_network_vim_id}",
4329 self
.vimconn
.logger
.error
.assert_not_called()
4331 @patch.object(vimconnector
, "_get_item_name_id")
4332 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4333 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4334 def test_delete_created_items_wth_keep_waiting_true(
4336 mock_delete_floating_ip_by_id
,
4337 mock_delete_volumes_by_id_wth_cinder
,
4338 mock_get_item_name_id
,
4340 """Keep waiting initial value is True."""
4342 f
"floating_ip:{floating_network_vim_id}": True,
4343 f
"volume:{volume_id}": True,
4344 f
"port:{port_id}": None,
4346 mock_get_item_name_id
.side_effect
= [
4347 ("floating_ip", f
"{floating_network_vim_id}"),
4348 ("volume", f
"{volume_id}"),
4350 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4351 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4353 result
= self
.vimconn
._delete
_created
_items
(
4354 created_items
, volumes_to_hold
, keep_waiting
4356 self
.assertEqual(result
, True)
4357 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4358 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4359 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4361 mock_delete_floating_ip_by_id
.assert_called_once_with(
4362 f
"floating_ip:{floating_network_vim_id}",
4363 f
"{floating_network_vim_id}",
4366 self
.vimconn
.logger
.error
.assert_not_called()
4368 @patch.object(vimconnector
, "_get_item_name_id")
4369 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4370 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4371 def test_delete_created_items__delete_vol_raises_connection_error__operation_fails(
4373 mock_delete_floating_ip_by_id
,
4374 mock_delete_volumes_by_id_wth_cinder
,
4375 mock_get_item_name_id
,
4377 """Delete volume raises exception."""
4379 f
"floating_ip:{floating_network_vim_id}": True,
4380 f
"volume:{volume_id}": True,
4381 f
"port:{port_id}": None,
4383 mock_get_item_name_id
.side_effect
= [
4384 ("floating_ip", f
"{floating_network_vim_id}"),
4385 ("volume", f
"{volume_id}"),
4387 mock_delete_volumes_by_id_wth_cinder
.side_effect
= (
4388 neExceptions
.ConnectionFailed("Connection failed.")
4390 volumes_to_hold
= []
4391 keep_waiting
= False
4392 with self
.assertRaises(VimConnConnectionException
):
4393 result
= self
.vimconn
._delete
_created
_items
(
4394 created_items
, volumes_to_hold
, keep_waiting
4396 self
.assertEqual(result
, None)
4397 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4398 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4399 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4401 mock_delete_floating_ip_by_id
.assert_called_once_with(
4402 f
"floating_ip:{floating_network_vim_id}",
4403 f
"{floating_network_vim_id}",
4406 self
.vimconn
.logger
.error
.assert_called_once_with(
4407 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
4410 @patch.object(vimconnector
, "_get_item_name_id")
4411 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4412 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4413 def test_delete_created_items__delete_fip_raises_connection_error__operation_fails(
4415 mock_delete_floating_ip_by_id
,
4416 mock_delete_volumes_by_id_wth_cinder
,
4417 mock_get_item_name_id
,
4419 """Delete floating ip raises exception."""
4421 f
"floating_ip:{floating_network_vim_id}": True,
4422 f
"volume:{volume_id}": True,
4423 f
"port:{port_id}": None,
4425 mock_get_item_name_id
.side_effect
= [
4426 ("floating_ip", f
"{floating_network_vim_id}"),
4427 ("volume", f
"{volume_id}"),
4429 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4430 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
4431 "Connection failed."
4433 volumes_to_hold
= []
4435 with self
.assertRaises(VimConnConnectionException
):
4436 result
= self
.vimconn
._delete
_created
_items
(
4437 created_items
, volumes_to_hold
, keep_waiting
4439 self
.assertEqual(result
, None)
4440 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
4441 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4442 mock_delete_floating_ip_by_id
.assert_called_once_with(
4443 f
"floating_ip:{floating_network_vim_id}",
4444 f
"{floating_network_vim_id}",
4447 self
.vimconn
.logger
.error
.assert_called_once_with(
4448 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
4451 @patch.object(vimconnector
, "_get_item_name_id")
4452 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4453 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4454 def test_delete_created_items_get_item_name_raises_type_error__operation_fails(
4456 mock_delete_floating_ip_by_id
,
4457 mock_delete_volumes_by_id_wth_cinder
,
4458 mock_get_item_name_id
,
4460 """Get item, name raises exception."""
4463 f
"volume{volume_id}": True,
4464 f
"port:{port_id}": None,
4466 mock_get_item_name_id
.side_effect
= [
4467 TypeError("Invalid Type"),
4468 AttributeError("Invalid attribute"),
4470 volumes_to_hold
= []
4471 keep_waiting
= False
4472 with self
.assertRaises(VimConnException
):
4473 result
= self
.vimconn
._delete
_created
_items
(
4474 created_items
, volumes_to_hold
, keep_waiting
4476 self
.assertEqual(result
, None)
4477 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
4478 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4479 mock_delete_floating_ip_by_id
.assert_not_called()
4480 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
4481 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
4483 @patch.object(vimconnector
, "_get_item_name_id")
4484 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4485 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4486 def test_delete_created_items_no_fip_wth_port(
4488 mock_delete_floating_ip_by_id
,
4489 mock_delete_volumes_by_id_wth_cinder
,
4490 mock_get_item_name_id
,
4492 """Created items has port, does not have floating ip."""
4494 f
"volume:{volume_id}": True,
4495 f
"port:{port_id}": True,
4497 mock_get_item_name_id
.side_effect
= [
4498 ("volume", f
"{volume_id}"),
4499 ("port", f
"{port_id}"),
4501 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4502 volumes_to_hold
= []
4503 keep_waiting
= False
4504 result
= self
.vimconn
._delete
_created
_items
(
4505 created_items
, volumes_to_hold
, keep_waiting
4507 self
.assertEqual(result
, False)
4508 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4509 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4510 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4512 mock_delete_floating_ip_by_id
.assert_not_called()
4513 self
.vimconn
.logger
.error
.assert_not_called()
4515 @patch.object(vimconnector
, "_get_item_name_id")
4516 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4517 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4518 def test_delete_created_items_no_volume(
4520 mock_delete_floating_ip_by_id
,
4521 mock_delete_volumes_by_id_wth_cinder
,
4522 mock_get_item_name_id
,
4524 """Created items does not have volume."""
4526 f
"floating_ip:{floating_network_vim_id}": True,
4527 f
"port:{port_id}": None,
4529 mock_get_item_name_id
.side_effect
= [
4530 ("floating_ip", f
"{floating_network_vim_id}")
4532 volumes_to_hold
= []
4533 keep_waiting
= False
4534 result
= self
.vimconn
._delete
_created
_items
(
4535 created_items
, volumes_to_hold
, keep_waiting
4537 self
.assertEqual(result
, False)
4538 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
4539 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4540 mock_delete_floating_ip_by_id
.assert_called_once_with(
4541 f
"floating_ip:{floating_network_vim_id}",
4542 f
"{floating_network_vim_id}",
4545 self
.vimconn
.logger
.error
.assert_not_called()
4547 @patch.object(vimconnector
, "_get_item_name_id")
4548 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4549 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4550 def test_delete_created_items_already_deleted(
4552 mock_delete_floating_ip_by_id
,
4553 mock_delete_volumes_by_id_wth_cinder
,
4554 mock_get_item_name_id
,
4556 """All created items are alerady deleted."""
4558 f
"floating_ip:{floating_network_vim_id}": None,
4559 f
"volume:{volume_id}": None,
4560 f
"port:{port_id}": None,
4562 volumes_to_hold
= []
4563 keep_waiting
= False
4564 result
= self
.vimconn
._delete
_created
_items
(
4565 created_items
, volumes_to_hold
, keep_waiting
4567 self
.assertEqual(result
, False)
4568 mock_get_item_name_id
.assert_not_called()
4569 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4570 mock_delete_floating_ip_by_id
.assert_not_called()
4571 self
.vimconn
.logger
.error
.assert_not_called()
4573 @patch("time.sleep")
4574 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4575 @patch.object(vimconnector
, "_format_exception")
4576 @patch.object(vimconnector
, "_reload_connection")
4577 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4578 @patch.object(vimconnector
, "_delete_created_items")
4579 def test_delete_vminstance_successfully(
4581 mock_delete_created_items
,
4582 mock_delete_vm_ports_attached_to_network
,
4583 mock_reload_connection
,
4584 mock_format_exception
,
4585 mock_extract_items_wth_keep_flag_from_created_items
,
4588 vm_id
= f
"{virtual_mac_id}"
4589 created_items
= deepcopy(created_items_all_true
)
4590 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4591 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4592 mock_delete_created_items
.return_value
= False
4593 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4594 mock_reload_connection
.assert_called_once()
4595 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4596 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4597 mock_delete_created_items
.assert_called_once_with(
4598 created_items
, volumes_to_hold
, False
4600 mock_sleep
.assert_not_called()
4601 mock_format_exception
.assert_not_called()
4602 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4606 @patch("time.sleep")
4607 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4608 @patch.object(vimconnector
, "_format_exception")
4609 @patch.object(vimconnector
, "_reload_connection")
4610 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4611 @patch.object(vimconnector
, "_delete_created_items")
4612 def test_delete_vminstance_created_items_has_keep_flag(
4614 mock_delete_created_items
,
4615 mock_delete_vm_ports_attached_to_network
,
4616 mock_reload_connection
,
4617 mock_format_exception
,
4618 mock_extract_items_wth_keep_flag_from_created_items
,
4621 """Created_items includes items which has keep flag."""
4622 vm_id
= f
"{virtual_mac_id}"
4623 initial_created_items
= {
4624 f
"port{port_id}": True,
4625 f
"floating_ip{floating_network_vim_id}": None,
4626 f
"volume{volume_id}keep": True,
4627 f
"volume{volume_id2}keep": True,
4630 f
"port{port_id}": True,
4631 f
"floating_ip{floating_network_vim_id}": None,
4633 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4634 volumes_to_hold
= []
4635 mock_delete_created_items
.return_value
= False
4636 self
.vimconn
.delete_vminstance(vm_id
, initial_created_items
, volumes_to_hold
)
4637 mock_reload_connection
.assert_called_once()
4638 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4639 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4640 mock_delete_created_items
.assert_called_once_with(
4641 created_items
, volumes_to_hold
, False
4643 mock_sleep
.assert_not_called()
4644 mock_format_exception
.assert_not_called()
4645 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4646 initial_created_items
4649 @patch("time.sleep")
4650 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4651 @patch.object(vimconnector
, "_reload_connection")
4652 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4653 @patch.object(vimconnector
, "_delete_created_items")
4654 def test_delete_vminstance__extract_items_wth_keep_raises_attributeerror__raise_vimconnexception(
4656 mock_delete_created_items
,
4657 mock_delete_vm_ports_attached_to_network
,
4658 mock_reload_connection
,
4659 mock_extract_items_wth_keep_flag_from_created_items
,
4662 """extract_items_wth_keep_flag_from_created_items raises AttributeError."""
4663 vm_id
= f
"{virtual_mac_id}"
4664 initial_created_items
= {
4665 f
"port{port_id}": True,
4666 f
"floating_ip{floating_network_vim_id}": None,
4667 f
"volume{volume_id}keep": True,
4668 f
"volume{volume_id2}keep": True,
4671 mock_extract_items_wth_keep_flag_from_created_items
.side_effect
= AttributeError
4672 volumes_to_hold
= []
4673 mock_delete_created_items
.return_value
= False
4674 with self
.assertRaises(VimConnException
):
4675 self
.vimconn
.delete_vminstance(
4676 vm_id
, initial_created_items
, volumes_to_hold
4678 mock_reload_connection
.assert_not_called()
4679 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4680 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4681 mock_delete_created_items
.assert_not_called()
4682 mock_sleep
.assert_not_called()
4683 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4684 initial_created_items
4687 @patch("time.sleep")
4688 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4689 @patch.object(vimconnector
, "_format_exception")
4690 @patch.object(vimconnector
, "_reload_connection")
4691 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4692 @patch.object(vimconnector
, "_delete_created_items")
4693 def test_delete_vminstance__delete_created_items_returns_true__delete_created_items_called_several_times(
4695 mock_delete_created_items
,
4696 mock_delete_vm_ports_attached_to_network
,
4697 mock_reload_connection
,
4698 mock_format_exception
,
4699 mock_extract_items_wth_keep_flag_from_created_items
,
4702 """Delete creted items raises exception."""
4703 vm_id
= f
"{virtual_mac_id}"
4704 created_items
= deepcopy(created_items_all_true
)
4705 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4706 mock_sleep
= MagicMock()
4707 volumes_to_hold
= []
4708 mock_delete_created_items
.side_effect
= [True, False]
4709 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4710 mock_reload_connection
.assert_called_once()
4711 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4712 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4713 self
.assertEqual(mock_delete_created_items
.call_count
, 2)
4714 mock_sleep
.assert_not_called()
4715 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4719 @patch("time.sleep")
4720 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4721 @patch.object(vimconnector
, "_reload_connection")
4722 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4723 @patch.object(vimconnector
, "_delete_created_items")
4724 def test_delete_vminstance__delete_vm_ports_raises_connection_error__raise_vimconnconnectionexception(
4726 mock_delete_created_items
,
4727 mock_delete_vm_ports_attached_to_network
,
4728 mock_reload_connection
,
4729 mock_extract_items_wth_keep_flag_from_created_items
,
4732 """Delete vm ports raises exception."""
4733 vm_id
= f
"{virtual_mac_id}"
4734 created_items
= deepcopy(created_items_all_true
)
4735 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4736 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4737 err
= ConnectionError("ClientException occurred.")
4738 mock_delete_vm_ports_attached_to_network
.side_effect
= err
4739 mock_delete_created_items
.return_value
= False
4740 with self
.assertRaises(VimConnConnectionException
):
4741 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4742 mock_reload_connection
.assert_called_once()
4743 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4744 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4745 mock_delete_created_items
.assert_not_called()
4746 mock_sleep
.assert_not_called()
4747 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4751 @patch("time.sleep")
4752 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4753 @patch.object(vimconnector
, "_reload_connection")
4754 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4755 @patch.object(vimconnector
, "_delete_created_items")
4756 def test_delete_vminstance__nova_server_delete_raises_clientexception__raise_vimconn_unexpected_response(
4758 mock_delete_created_items
,
4759 mock_delete_vm_ports_attached_to_network
,
4760 mock_reload_connection
,
4761 mock_extract_items_wth_keep_flag_from_created_items
,
4764 """Nova server delete raises exception."""
4765 vm_id
= f
"{virtual_mac_id}"
4766 created_items
= deepcopy(created_items_all_true
)
4767 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4768 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4769 err
= nvExceptions
.ClientException("ClientException occurred.")
4770 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
4771 mock_delete_created_items
.side_effect
= err
4772 with self
.assertRaises(VimConnUnexpectedResponse
):
4773 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4774 mock_reload_connection
.assert_called_once()
4775 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4776 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4777 mock_delete_created_items
.assert_not_called()
4778 mock_sleep
.assert_not_called()
4779 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4783 @patch("time.sleep")
4784 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4785 @patch.object(vimconnector
, "_reload_connection")
4786 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4787 @patch.object(vimconnector
, "_delete_created_items")
4788 def test_delete_vminstance__reload_connection_raises_connection_error__raises_vimconnconnection_exception(
4790 mock_delete_created_items
,
4791 mock_delete_vm_ports_attached_to_network
,
4792 mock_reload_connection
,
4793 mock_extract_items_wth_keep_flag_from_created_items
,
4796 """Reload connection raises exception."""
4797 vm_id
= f
"{virtual_mac_id}"
4798 created_items
= deepcopy(created_items_all_true
)
4799 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4800 mock_sleep
= MagicMock()
4801 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4802 err
= ConnectionError("ClientException occurred.")
4803 mock_delete_created_items
.return_value
= False
4804 mock_reload_connection
.side_effect
= err
4805 with self
.assertRaises(VimConnConnectionException
):
4806 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4807 mock_reload_connection
.assert_called_once()
4808 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4809 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4810 mock_delete_created_items
.assert_not_called()
4811 mock_sleep
.assert_not_called()
4812 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4816 @patch("time.sleep")
4817 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4818 @patch.object(vimconnector
, "_format_exception")
4819 @patch.object(vimconnector
, "_reload_connection")
4820 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4821 @patch.object(vimconnector
, "_delete_created_items")
4822 def test_delete_vminstance_created_item_vol_to_hold_are_none(
4824 mock_delete_created_items
,
4825 mock_delete_vm_ports_attached_to_network
,
4826 mock_reload_connection
,
4827 mock_format_exception
,
4828 mock_extract_items_wth_keep_flag_from_created_items
,
4831 """created_items and volumes_to_hold are None."""
4832 vm_id
= f
"{virtual_mac_id}"
4833 created_items
= None
4834 volumes_to_hold
= None
4835 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= {}
4836 mock_delete_created_items
.return_value
= False
4837 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4838 mock_reload_connection
.assert_called_once()
4839 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4840 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4841 mock_delete_created_items
.assert_called_once_with({}, [], False)
4842 mock_sleep
.assert_not_called()
4843 mock_format_exception
.assert_not_called()
4844 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with({})
4846 @patch("time.sleep")
4847 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4848 @patch.object(vimconnector
, "_format_exception")
4849 @patch.object(vimconnector
, "_reload_connection")
4850 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4851 @patch.object(vimconnector
, "_delete_created_items")
4852 def test_delete_vminstance_vm_id_is_none(
4854 mock_delete_created_items
,
4855 mock_delete_vm_ports_attached_to_network
,
4856 mock_reload_connection
,
4857 mock_format_exception
,
4858 mock_extract_items_wth_keep_flag_from_created_items
,
4861 """vm_id is None."""
4863 created_items
= deepcopy(created_items_all_true
)
4864 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4865 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4866 mock_delete_created_items
.side_effect
= [True, True, False]
4867 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4868 mock_reload_connection
.assert_called_once()
4869 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4870 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4871 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
4872 self
.assertEqual(mock_sleep
.call_count
, 2)
4873 mock_format_exception
.assert_not_called()
4874 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4878 @patch("time.sleep")
4879 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4880 @patch.object(vimconnector
, "_format_exception")
4881 @patch.object(vimconnector
, "_reload_connection")
4882 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4883 @patch.object(vimconnector
, "_delete_created_items")
4884 def test_delete_vminstance_delete_created_items_return_true(
4886 mock_delete_created_items
,
4887 mock_delete_vm_ports_attached_to_network
,
4888 mock_reload_connection
,
4889 mock_format_exception
,
4890 mock_extract_items_wth_keep_flag_from_created_items
,
4893 """Delete created items always return True."""
4895 created_items
= deepcopy(created_items_all_true
)
4896 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4897 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4898 mock_delete_created_items
.side_effect
= [True] * 1800
4899 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4900 mock_reload_connection
.assert_called_once()
4901 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4902 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4903 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
4904 self
.assertEqual(mock_sleep
.call_count
, 1800)
4905 mock_format_exception
.assert_not_called()
4906 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4910 def test_remove_keep_tag_from_persistent_volumes_keep_flag_exists(self
):
4911 """Keep flag exists in created items."""
4913 f
"port:{port_id}": True,
4914 f
"floating_ip:{floating_network_vim_id}": True,
4915 f
"volume:{volume_id}:keep": True,
4916 f
"volume:{volume_id2}:keep": True,
4919 f
"port:{port_id}": True,
4920 f
"floating_ip:{floating_network_vim_id}": True,
4921 f
"volume:{volume_id}": True,
4922 f
"volume:{volume_id2}": True,
4924 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4925 self
.assertDictEqual(result
, expected_result
)
4927 def test_remove_keep_tag_from_persistent_volumes_without_keep_flag(self
):
4928 """Keep flag does not exist in created items."""
4930 f
"port:{port_id}": True,
4931 f
"floating_ip:{floating_network_vim_id}": True,
4932 f
"volume:{volume_id}": True,
4933 f
"volume:{volume_id2}": True,
4935 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4936 self
.assertDictEqual(result
, created_items
)
4938 def test_update_block_device_mapping_empty_volume(self
):
4940 block_device_mapping
= {}
4941 base_disk_index
= 100
4944 with self
.assertRaises(VimConnException
) as err
:
4945 self
.vimconn
.update_block_device_mapping(
4946 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4948 self
.assertEqual(str(err
), "Volume is empty.")
4949 self
.assertEqual(block_device_mapping
, {})
4950 self
.assertEqual(created_items
, {})
4952 def test_update_block_device_mapping_invalid_volume(self
):
4954 block_device_mapping
= {}
4955 base_disk_index
= 100
4958 with self
.assertRaises(VimConnException
) as err
:
4959 self
.vimconn
.update_block_device_mapping(
4960 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4963 str(err
), "Created volume is not valid, does not have id attribute."
4965 self
.assertEqual(block_device_mapping
, {})
4966 self
.assertEqual(created_items
, {})
4968 def test_update_block_device_mapping(self
):
4969 volume
= MagicMock(autospec
=True)
4970 volume
.id = volume_id
4971 block_device_mapping
= {}
4972 base_disk_index
= 100
4975 self
.vimconn
.update_block_device_mapping(
4976 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4979 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4982 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a": True}
4985 def test_update_block_device_mapping_with_keep_flag(self
):
4986 volume
= MagicMock(autospec
=True)
4987 volume
.id = volume_id
4988 block_device_mapping
= {}
4989 base_disk_index
= 100
4990 disk
= {"size": 10, "keep": True}
4992 self
.vimconn
.update_block_device_mapping(
4993 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4996 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4999 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a:keep": True}
5002 def test_extract_items_with_keep_flag_item_has_keep_flag(self
):
5003 created_items
= deepcopy(created_items_all_true
)
5004 created_items
[f
"volume:{volume_id2}:keep"] = True
5005 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5008 self
.assertEqual(result
, deepcopy(created_items_all_true
))
5010 def test_extract_items_with_keep_flag_no_item_wth_keep_flag(self
):
5011 created_items
= deepcopy(created_items_all_true
)
5012 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5015 self
.assertEqual(result
, deepcopy(created_items_all_true
))
5017 def test_extract_items_with_keep_flag_all_items_are_already_deleted(self
):
5019 f
"port:{port_id}": None,
5020 f
"floating_ip:{floating_network_vim_id}": None,
5021 f
"volume:{volume_id}:keep": None,
5022 f
"volume:{volume_id2}:keep": None,
5025 f
"port:{port_id}": None,
5026 f
"floating_ip:{floating_network_vim_id}": None,
5028 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5031 self
.assertEqual(result
, expected_result
)
5033 def test_extract_items_with_keep_flag_without_semicolon(self
):
5035 f
"port{port_id}": True,
5036 f
"floating_ip{floating_network_vim_id}": None,
5037 f
"volume{volume_id}keep": True,
5038 f
"volume{volume_id2}keep": True,
5040 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5043 self
.assertEqual(result
, {})
5045 def test_extract_items_with_keep_flag_invalid_type_created_items(self
):
5046 created_items
= [{f
"port{port_id}": True}, {f
"volume{volume_id2}keep": True}]
5047 with self
.assertRaises(AttributeError):
5048 self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(created_items
)
5050 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5051 def test_get_monitoring_data(self
, mock_reload_conection
):
5053 {"original_name": "flavor1", "id": "367fc1eb-bd22-40f8-a519-ed2fb4e5976b"},
5054 {"original_name": "flavor2", "id": "5dcf9732-d17d-40b3-910d-37fc4c5aacc0"},
5058 "server1", "ACTIVE", flavors
[0], "312200db-42e3-4772-9518-d5db85468392"
5061 "server2", "ACTIVE", flavors
[1], "39a166cf-e4e6-479c-b88c-9ad558cf2cbf"
5064 ports
= {"ports": ["port1", "port2"]}
5065 self
.vimconn
.nova
.servers
.list.return_value
= servers
5066 self
.vimconn
.neutron
.list_ports
.return_value
= ports
5067 result
= self
.vimconn
.get_monitoring_data()
5068 self
.assertTupleEqual(result
, (servers
, ports
))
5069 mock_reload_conection
.assert_called_once()
5070 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5071 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5073 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5074 def test_get_monitoring_data_reload_connection_raises(self
, mock_reload_conection
):
5075 mock_reload_conection
.side_effect
= VimConnNotFoundException(
5076 "Connection object not found."
5078 with self
.assertRaises(VimConnException
) as err
:
5079 result
= self
.vimconn
.get_monitoring_data()
5080 self
.assertTupleEqual(result
, None)
5082 str(err
.exception
.args
[0]),
5083 "Exception in monitoring while getting VMs and ports status: Connection object not found.",
5085 mock_reload_conection
.assert_called_once()
5086 check_if_assert_not_called(
5087 [self
.vimconn
.nova
.servers
.list, self
.vimconn
.neutron
.list_ports
]
5090 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5091 def test_get_monitoring_data_server_list_raises(self
, mock_reload_conection
):
5092 self
.vimconn
.nova
.servers
.list.side_effect
= VimConnConnectionException(
5093 "Can not connect to Cloud API."
5095 with self
.assertRaises(VimConnException
) as err
:
5096 result
= self
.vimconn
.get_monitoring_data()
5097 self
.assertTupleEqual(result
, None)
5099 str(err
.exception
.args
[0]),
5100 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5102 mock_reload_conection
.assert_called_once()
5103 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5104 self
.vimconn
.neutron
.list_ports
.assert_not_called()
5106 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5107 def test_get_monitoring_data_list_ports_raises(self
, mock_reload_conection
):
5108 self
.vimconn
.neutron
.list_ports
.side_effect
= VimConnConnectionException(
5109 "Can not connect to Cloud API."
5111 with self
.assertRaises(VimConnException
) as err
:
5112 result
= self
.vimconn
.get_monitoring_data()
5113 self
.assertTupleEqual(result
, None)
5115 str(err
.exception
.args
[0]),
5116 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5118 mock_reload_conection
.assert_called_once()
5119 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5120 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5123 class TestNewFlavor(unittest
.TestCase
):
5124 @patch("logging.getLogger", autospec
=True)
5125 def setUp(self
, mock_logger
):
5126 # We are disabling the logging of exception not to print them to console.
5127 mock_logger
= logging
.getLogger()
5128 mock_logger
.disabled
= True
5129 self
.vimconn
= vimconnector(
5139 self
.vimconn
.nova
= CopyingMock(autospec
=True)
5140 self
.flavor1
= CopyingMock(autospec
=True, name
="sample-flavor")
5141 self
.flavor2
= CopyingMock(autospec
=True, name
="other-flavor")
5142 self
.new_flavor
= CopyingMock(autospec
=True, name
="new_flavor")
5143 self
.new_flavor
.id = "075d2482-5edb-43e3-91b3-234e65b6268a"
5144 self
.vimconn
.nova
.flavors
.create
.return_value
= self
.new_flavor
5146 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5147 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5148 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5151 "process_numa_paired_threads",
5152 new_callable
=CopyingMock(),
5154 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5155 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5156 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_vio(
5158 mock_process_numa_threads
,
5159 mock_process_numa_cores
,
5160 mock_process_numa_paired_threads
,
5161 mock_process_numa_vcpu
,
5162 mock_process_numa_memory
,
5163 mock_process_vio_numa_nodes
,
5165 """Process numa parameters, id, memory, vcpu exist, vim type is VIO,
5166 paired-threads, cores, threads do not exist in numa.
5169 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5170 {"id": 1, "memory": 2, "vcpu": [2]},
5173 expected_extra_specs
= {
5174 "hw:numa_nodes": "2",
5175 "hw:cpu_sockets": "2",
5177 self
.vimconn
.vim_type
= "VIO"
5178 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5180 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5181 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5182 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5183 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5185 _call_mock_process_numa_memory
[0].args
,
5187 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5190 "hw:numa_nodes": "2",
5195 _call_mock_process_numa_memory
[1].args
,
5197 {"id": 1, "memory": 2, "vcpu": [2]},
5200 "hw:cpu_sockets": "2",
5201 "hw:numa_nodes": "2",
5205 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5207 _call_mock_process_numa_vcpu
[0].args
,
5209 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5212 "hw:numa_nodes": "2",
5217 _call_mock_process_numa_vcpu
[1].args
,
5219 {"id": 1, "memory": 2, "vcpu": [2]},
5222 "hw:cpu_sockets": "2",
5223 "hw:numa_nodes": "2",
5227 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5228 check_if_assert_not_called(
5230 mock_process_numa_threads
,
5231 mock_process_numa_cores
,
5232 mock_process_numa_paired_threads
,
5236 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5237 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5238 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5241 "process_numa_paired_threads",
5242 new_callable
=CopyingMock(),
5244 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5245 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5246 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_openstack(
5248 mock_process_numa_threads
,
5249 mock_process_numa_cores
,
5250 mock_process_numa_paired_threads
,
5251 mock_process_numa_vcpu
,
5252 mock_process_numa_memory
,
5253 mock_process_vio_numa_nodes
,
5255 """Process numa parameters, id, memory, vcpu exist, vim type is openstack,
5256 paired-threads, cores, threads do not exist in numa.
5259 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5260 {"id": 1, "memory": 2, "vcpu": [2]},
5263 expected_extra_specs
= {
5264 "hw:numa_nodes": "2",
5265 "hw:cpu_sockets": "2",
5267 self
.vimconn
.vim_type
= "openstack"
5268 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5270 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5271 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5272 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5274 _call_mock_process_numa_memory
[0].args
,
5276 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5278 {"hw:numa_nodes": "2"},
5282 _call_mock_process_numa_memory
[1].args
,
5284 {"id": 1, "memory": 2, "vcpu": [2]},
5286 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5289 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5291 _call_mock_process_numa_vcpu
[0].args
,
5293 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5295 {"hw:numa_nodes": "2"},
5299 _call_mock_process_numa_vcpu
[1].args
,
5301 {"id": 1, "memory": 2, "vcpu": [2]},
5303 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5306 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5307 check_if_assert_not_called(
5309 mock_process_numa_threads
,
5310 mock_process_numa_cores
,
5311 mock_process_numa_paired_threads
,
5315 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5316 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5317 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5320 "process_numa_paired_threads",
5321 new_callable
=CopyingMock(),
5323 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5324 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5325 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_openstack_extra_spec_not_empty(
5327 mock_process_numa_threads
,
5328 mock_process_numa_cores
,
5329 mock_process_numa_paired_threads
,
5330 mock_process_numa_vcpu
,
5331 mock_process_numa_memory
,
5332 mock_process_vio_numa_nodes
,
5334 """Process numa parameters, id, paired-threads exist, vim type is openstack.
5335 vcpus calculation according to paired-threads in numa, there is extra_spec.
5337 numas
= [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
5338 extra_specs
= {"some-key": "some-value"}
5339 expected_extra_specs
= {
5340 "hw:cpu_sockets": "2",
5341 "hw:cpu_threads": "12",
5342 "hw:numa_nodes": "2",
5343 "some-key": "some-value",
5345 self
.vimconn
.vim_type
= "openstack"
5346 mock_process_numa_paired_threads
.side_effect
= [6, 6]
5347 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5349 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5350 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5351 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5352 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5353 _call_mock_process_numa_paired_threads
= (
5354 mock_process_numa_paired_threads
.call_args_list
5357 _call_mock_process_numa_paired_threads
[0].args
,
5359 {"id": 0, "paired-threads": 3},
5360 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5364 _call_mock_process_numa_paired_threads
[1].args
,
5366 {"id": 1, "paired-threads": 3},
5367 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5370 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5372 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5373 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5374 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5377 "process_numa_paired_threads",
5378 new_callable
=CopyingMock(),
5380 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5381 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5382 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_vio_extra_spec_not_empty(
5384 mock_process_numa_threads
,
5385 mock_process_numa_cores
,
5386 mock_process_numa_paired_threads
,
5387 mock_process_numa_vcpu
,
5388 mock_process_numa_memory
,
5389 mock_process_vio_numa_nodes
,
5391 """Process numa parameters, id, paired-threads exist, vim type is VIO.
5392 vcpus calculation according to paired-threads in numa, there is extra_spec.
5394 numas
= [{"id": 0, "paired-threads": 2}, {"id": 1, "paired-threads": 2}]
5395 extra_specs
= {"some-key": "some-value"}
5396 expected_extra_specs
= {
5397 "hw:numa_nodes": "2",
5398 "hw:cpu_sockets": "2",
5399 "hw:cpu_threads": "8",
5400 "some-key": "some-value",
5402 self
.vimconn
.vim_type
= "VIO"
5403 mock_process_numa_paired_threads
.side_effect
= [4, 4]
5404 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5405 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5406 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5407 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5408 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5409 _call_mock_process_numa_paired_threads
= (
5410 mock_process_numa_paired_threads
.call_args_list
5412 mock_process_vio_numa_nodes
.assert_called_once_with(
5413 2, {"some-key": "some-value", "hw:numa_nodes": "2"}
5416 _call_mock_process_numa_paired_threads
[0].args
,
5418 {"id": 0, "paired-threads": 2},
5420 "hw:cpu_sockets": "2",
5421 "hw:numa_nodes": "2",
5422 "some-key": "some-value",
5427 _call_mock_process_numa_paired_threads
[1].args
,
5429 {"id": 1, "paired-threads": 2},
5431 "hw:cpu_sockets": "2",
5432 "hw:numa_nodes": "2",
5433 "some-key": "some-value",
5437 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5439 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5440 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5441 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5444 "process_numa_paired_threads",
5445 new_callable
=CopyingMock(),
5447 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5448 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5449 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_openstack(
5451 mock_process_numa_threads
,
5452 mock_process_numa_cores
,
5453 mock_process_numa_paired_threads
,
5454 mock_process_numa_vcpu
,
5455 mock_process_numa_memory
,
5456 mock_process_vio_numa_nodes
,
5458 """Process numa parameters, id, cores exist, vim type is openstack.
5459 vcpus calculation according to cores in numa.
5461 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5463 updated_extra_specs
= {"hw:numa_nodes": "2", "hw:cpu_sockets": "2"}
5464 expected_extra_specs
= {
5465 "hw:numa_nodes": "2",
5466 "hw:cpu_sockets": "2",
5467 "hw:cpu_cores": "3",
5469 self
.vimconn
.vim_type
= "openstack"
5470 mock_process_numa_cores
.side_effect
= [1, 2]
5471 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5473 check_if_assert_not_called(
5474 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5476 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5477 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5478 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5479 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5481 _call_mock_process_numa_cores
[0].args
,
5482 ({"id": 0, "cores": 1}, updated_extra_specs
),
5485 _call_mock_process_numa_cores
[1].args
,
5486 ({"id": 1, "cores": 2}, updated_extra_specs
),
5488 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5490 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5491 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5492 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5495 "process_numa_paired_threads",
5496 new_callable
=CopyingMock(),
5498 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5499 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5500 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_vio(
5502 mock_process_numa_threads
,
5503 mock_process_numa_cores
,
5504 mock_process_numa_paired_threads
,
5505 mock_process_numa_vcpu
,
5506 mock_process_numa_memory
,
5507 mock_process_vio_numa_nodes
,
5509 """Process numa parameters, id, cores exist, vim type is VIO.
5510 vcpus calculation according to cores in numa.
5512 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5514 expected_extra_specs
= {
5515 "hw:cpu_cores": "3",
5516 "hw:cpu_sockets": "2",
5517 "hw:numa_nodes": "2",
5519 self
.vimconn
.vim_type
= "VIO"
5520 mock_process_numa_cores
.side_effect
= [1, 2]
5521 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5522 check_if_assert_not_called(
5523 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5525 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5526 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5527 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5528 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5529 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5531 _call_mock_process_numa_cores
[0].args
,
5533 {"id": 0, "cores": 1},
5535 "hw:cpu_sockets": "2",
5536 "hw:numa_nodes": "2",
5541 _call_mock_process_numa_cores
[1].args
,
5543 {"id": 1, "cores": 2},
5545 "hw:cpu_sockets": "2",
5546 "hw:numa_nodes": "2",
5550 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5552 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5553 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5554 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5557 "process_numa_paired_threads",
5558 new_callable
=CopyingMock(),
5560 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5561 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5562 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_vio(
5564 mock_process_numa_threads
,
5565 mock_process_numa_cores
,
5566 mock_process_numa_paired_threads
,
5567 mock_process_numa_vcpu
,
5568 mock_process_numa_memory
,
5569 mock_process_vio_numa_nodes
,
5571 """Process numa parameters, memory, vcpu, thread exist, vim type is VIO,
5572 vcpus calculation according threads in numa, there are not numa ids.
5575 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5576 {"memory": 2, "vcpu": [2]},
5579 expected_extra_specs
= {
5580 "hw:numa_nodes": "2",
5581 "hw:cpu_sockets": "2",
5582 "hw:cpu_threads": "3",
5584 self
.vimconn
.vim_type
= "VIO"
5585 mock_process_numa_threads
.return_value
= 3
5586 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5587 check_if_assert_not_called(
5589 mock_process_numa_memory
,
5590 mock_process_numa_vcpu
,
5591 mock_process_numa_cores
,
5592 mock_process_numa_paired_threads
,
5595 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5596 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5597 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5599 _call_mock_process_numa_threads
[0].args
,
5601 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5603 "hw:cpu_sockets": "2",
5604 "hw:numa_nodes": "2",
5608 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5610 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5611 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5612 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5615 "process_numa_paired_threads",
5616 new_callable
=CopyingMock(autospec
=True),
5618 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5619 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5620 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_openstack(
5622 mock_process_numa_threads
,
5623 mock_process_numa_cores
,
5624 mock_process_numa_paired_threads
,
5625 mock_process_numa_vcpu
,
5626 mock_process_numa_memory
,
5627 mock_process_vio_numa_nodes
,
5629 """Process numa parameters, memory, vcpu, thread exist, vim type is openstack,
5630 vcpus calculation according threads in numa, there are not numa ids.
5633 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5634 {"memory": 2, "vcpu": [2]},
5637 expected_extra_specs
= {
5638 "hw:numa_nodes": "2",
5639 "hw:cpu_sockets": "2",
5640 "hw:cpu_threads": "3",
5642 self
.vimconn
.vim_type
= "openstack"
5643 mock_process_numa_threads
.return_value
= 3
5644 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5646 check_if_assert_not_called(
5648 mock_process_numa_memory
,
5649 mock_process_numa_vcpu
,
5650 mock_process_numa_cores
,
5651 mock_process_numa_paired_threads
,
5652 mock_process_vio_numa_nodes
,
5655 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5656 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5658 _call_mock_process_numa_threads
[0].args
,
5660 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5661 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5664 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5666 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5667 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5668 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5671 "process_numa_paired_threads",
5672 new_callable
=CopyingMock(),
5674 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5675 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5676 def test_process_numa_parameters_of_flavor_empty_numas_list_type_vio(
5678 mock_process_numa_threads
,
5679 mock_process_numa_cores
,
5680 mock_process_numa_paired_threads
,
5681 mock_process_numa_vcpu
,
5682 mock_process_numa_memory
,
5683 mock_process_vio_numa_nodes
,
5685 """Numa list is empty, vim type is VIO."""
5688 expected_extra_specs
= {"hw:numa_nodes": "0"}
5689 self
.vimconn
.vim_type
= "VIO"
5690 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5691 check_if_assert_not_called(
5693 mock_process_numa_memory
,
5694 mock_process_numa_vcpu
,
5695 mock_process_numa_cores
,
5696 mock_process_numa_paired_threads
,
5697 mock_process_numa_threads
,
5700 mock_process_vio_numa_nodes
.assert_called_once_with(0, {"hw:numa_nodes": "0"})
5701 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5703 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5704 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5705 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5708 "process_numa_paired_threads",
5709 new_callable
=CopyingMock(),
5711 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5712 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5713 def test_process_numa_parameters_of_flavor_empty_numas_list_type_openstack(
5715 mock_process_numa_threads
,
5716 mock_process_numa_cores
,
5717 mock_process_numa_paired_threads
,
5718 mock_process_numa_vcpu
,
5719 mock_process_numa_memory
,
5720 mock_process_vio_numa_nodes
,
5722 """Numa list is empty, vim type is openstack."""
5725 expected_extra_specs
= {"hw:numa_nodes": "0"}
5726 self
.vimconn
.vim_type
= "openstack"
5727 mock_process_numa_threads
.return_value
= None
5728 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5730 check_if_assert_not_called(
5732 mock_process_numa_memory
,
5733 mock_process_numa_vcpu
,
5734 mock_process_numa_cores
,
5735 mock_process_numa_paired_threads
,
5736 mock_process_numa_threads
,
5737 mock_process_vio_numa_nodes
,
5740 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5742 def test_process_numa_memory_empty_extra_spec(self
):
5743 numa
= {"memory": 2, "vcpu": [2]}
5746 expected_extra_spec
= {"hw:numa_mem.2": 2048}
5747 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5748 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5750 def test_process_numa_memory_not_exist(self
):
5751 numa
= {"vcpu": [2]}
5753 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5754 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5755 self
.assertDictEqual(extra_specs
, {"vmware:latency_sensitivity_level": "high"})
5757 def test_process_numa_memory_node_id_is_none(self
):
5758 numa
= {"memory": 2, "vcpu": [2]}
5761 expected_extra_spec
= {"hw:numa_mem.None": 2048}
5762 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5763 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5765 def test_process_numa_vcpu_empty_extra_spec(self
):
5766 numa
= {"vcpu": [2]}
5769 expected_extra_spec
= {"hw:numa_cpus.0": "2"}
5770 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5771 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5773 def test_process_numa_vcpu_not_exist(self
):
5774 numa
= {"memory": 2}
5776 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5777 expected_extra_spec
= {"vmware:latency_sensitivity_level": "high"}
5778 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5779 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5781 def test_process_numa_vcpu_empty_node_id(self
):
5782 numa
= {"vcpu": [2]}
5785 expected_extra_spec
= {"hw:numa_cpus.": "2"}
5786 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5787 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5789 def test_process_numa_vcpu_empty_numa_dict(self
):
5793 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5794 self
.assertDictEqual(extra_specs
, {})
5796 def test_process_numa_vcpu_str_node_id(self
):
5797 numa
= {"vcpu": [2]}
5800 expected_extra_spec
= {"hw:numa_cpus.12": "2"}
5801 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5802 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5804 def test_process_numa_paired_threads_empty_extra_spec(self
):
5805 numa
= {"id": 0, "paired-threads": 3}
5807 expected_extra_spec
= {
5808 "hw:cpu_thread_policy": "require",
5809 "hw:cpu_policy": "dedicated",
5811 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5812 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5813 self
.assertEqual(result
, 6)
5815 def test_process_numa_paired_threads_empty_numa(self
):
5818 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5819 self
.assertDictEqual(extra_specs
, {})
5820 self
.assertEqual(result
, None)
5822 def test_process_numa_paired_threads_not_exist(self
):
5823 numa
= {"vcpu": [2]}
5825 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5826 self
.assertDictEqual(extra_specs
, {})
5827 self
.assertEqual(result
, None)
5829 def test_process_numa_paired_threads_str_thread_num(self
):
5830 numa
= {"id": 0, "paired-threads": "3"}
5832 expected_extra_spec
= {
5833 "hw:cpu_thread_policy": "require",
5834 "hw:cpu_policy": "dedicated",
5836 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5837 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5838 self
.assertEqual(result
, "33")
5840 def test_process_numa_paired_threads_none_thread_num(self
):
5841 numa
= {"id": 0, "paired-threads": None}
5843 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5844 self
.assertDictEqual(extra_specs
, {})
5845 self
.assertEqual(result
, None)
5847 def test_process_numa_cores_empty_extra_spec(self
):
5848 numa
= {"id": 0, "cores": 1}
5850 expected_extra_spec
= {
5851 "hw:cpu_policy": "dedicated",
5852 "hw:cpu_thread_policy": "isolate",
5854 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5855 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5856 self
.assertEqual(result
, 1)
5858 def test_process_numa_cores_not_exist(self
):
5859 numa
= {"id": 0, "paired-threads": 3}
5861 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5862 self
.assertDictEqual(extra_specs
, {})
5863 self
.assertEqual(result
, None)
5865 def test_process_numa_cores_empty_numa(self
):
5867 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5868 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5869 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5870 self
.assertEqual(result
, None)
5872 def test_process_numa_cores_none_core_num(self
):
5873 numa
= {"memory": 1, "cores": None}
5875 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5876 self
.assertDictEqual(extra_specs
, {})
5877 self
.assertEqual(result
, None)
5879 def test_process_numa_cores_string_core_num(self
):
5880 numa
= {"id": 0, "cores": "1"}
5881 extra_specs
= {"some-key": "some-val"}
5882 expected_extra_spec
= {
5883 "hw:cpu_policy": "dedicated",
5884 "hw:cpu_thread_policy": "isolate",
5885 "some-key": "some-val",
5887 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5888 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5889 self
.assertEqual(result
, "1")
5891 def test_process_numa_cores_float_core_num(self
):
5892 numa
= {"memory": 2, "cores": 10.03}
5893 extra_specs
= {"some-key": "some-val"}
5894 expected_extra_spec
= {
5895 "hw:cpu_policy": "dedicated",
5896 "hw:cpu_thread_policy": "isolate",
5897 "some-key": "some-val",
5899 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5900 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5901 self
.assertEqual(result
, 10.03)
5903 def test_process_numa_threads_empty_extra_spec_int_thread_num(self
):
5904 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3}
5906 expected_extra_spec
= {
5907 "hw:cpu_policy": "dedicated",
5908 "hw:cpu_thread_policy": "prefer",
5910 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5911 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5912 self
.assertEqual(result
, 3)
5914 def test_process_numa_threads_empty_numa(self
):
5916 extra_specs
= {"some-key": "some-val"}
5917 expected_extra_spec
= {"some-key": "some-val"}
5918 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5919 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5920 self
.assertEqual(result
, None)
5922 def test_process_numa_threads_not_exist(self
):
5923 numa
= {"memory": 1}
5924 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5925 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5926 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5927 self
.assertEqual(result
, None)
5929 def test_process_numa_threads_str_thread_num(self
):
5930 numa
= {"vcpu": [1, 3], "threads": "3"}
5932 expected_extra_spec
= {
5933 "hw:cpu_policy": "dedicated",
5934 "hw:cpu_thread_policy": "prefer",
5936 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5937 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5938 self
.assertEqual(result
, "3")
5940 def test_process_numa_threads_none_thread_num(self
):
5941 numa
= {"vcpu": [1, 3], "threads": None}
5943 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5944 self
.assertDictEqual(extra_specs
, {})
5945 self
.assertEqual(result
, None)
5947 def test_process_numa_threads_float_thread_num(self
):
5948 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3.3}
5949 extra_specs
= {"some-key": "some-val"}
5950 expected_extra_spec
= {
5951 "hw:cpu_policy": "dedicated",
5952 "hw:cpu_thread_policy": "prefer",
5953 "some-key": "some-val",
5955 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5956 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5957 self
.assertEqual(result
, 3.3)
5959 def test_change_the_flavor_name_not_existing_name(self
):
5960 """Flavor name does not exist in Openstack flavor list."""
5961 self
.flavor1
.name
= "sample-flavor-3"
5962 self
.flavor2
.name
= "other-flavor-4"
5963 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5964 name
= "other-flavor-3"
5966 flavor_data
= {"name": "other-flavor"}
5967 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5968 self
.assertEqual(result
, name
)
5969 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5970 # Checking whether name_suffix changed or not.
5971 self
.assertEqual(name_suffix
, 3)
5973 def test_change_the_flavor_name_existing_name(self
):
5974 """Flavor name exists in Openstack flavor list."""
5975 self
.flavor1
.name
= "other-flavor-6"
5976 self
.flavor2
.name
= "other-flavor-3"
5977 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5978 name
= "other-flavor-3"
5980 flavor_data
= {"name": "other-flavor"}
5981 expected_result
= "other-flavor-7"
5982 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5983 self
.assertEqual(result
, expected_result
)
5984 # Checking whether name_suffix changed or not.
5985 self
.assertEqual(name_suffix
, 5)
5986 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5988 def test_change_the_flavor_name_flavor_data_does_not_have_name(self
):
5989 """Flavor data does not have name."""
5990 self
.flavor1
.name
= "other-flavor-6"
5991 self
.flavor2
.name
= "other-flavor-3"
5992 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5993 name
= "other-flavor-3"
5996 with self
.assertRaises(KeyError):
5997 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5998 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5999 # Checking whether name_suffix changed or not.
6000 self
.assertEqual(name_suffix
, 5)
6002 def test_change_the_flavor_name_invalid_name_suffix(self
):
6003 """Name suffix is invalid."""
6004 self
.flavor1
.name
= "other-flavor-6"
6005 self
.flavor2
.name
= "other-flavor-3"
6006 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6007 name
= "other-flavor-3"
6009 flavor_data
= {"name": "other-flavor"}
6010 with self
.assertRaises(TypeError):
6011 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6012 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6013 # Checking whether name_suffix changed or not.
6014 self
.assertEqual(name_suffix
, "a")
6016 def test_change_the_flavor_name_given_name_is_empty(self
):
6017 """Given name is empty string."""
6018 self
.flavor1
.name
= "other-flavor-6"
6019 self
.flavor2
.name
= "other-flavor-3"
6020 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6023 flavor_data
= {"name": "other-flavor"}
6024 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6025 self
.assertEqual(result
, "")
6026 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6027 # Checking whether name_suffix increased or not.
6028 self
.assertEqual(name_suffix
, 3)
6030 def test_change_the_flavor_name_given_name_is_none(self
):
6031 """Given name is None."""
6032 self
.flavor1
.name
= "other-flavor-6"
6033 self
.flavor2
.name
= "other-flavor-3"
6034 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6037 flavor_data
= {"name": "other-flavor"}
6038 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6039 self
.assertEqual(result
, None)
6040 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6041 # Checking whether name_suffix increased or not.
6042 self
.assertEqual(name_suffix
, 6)
6044 def test_change_the_flavor_name_empty_nova_flavor_list(self
):
6045 """Nova flavor list is empty."""
6046 self
.vimconn
.nova
.flavors
.list.return_value
= []
6047 name
= "other-flavor-3"
6049 flavor_data
= {"name": "other-flavor"}
6050 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6051 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6052 self
.assertEqual(result
, name
)
6053 # Checking whether name_suffix increased or not.
6054 self
.assertEqual(name_suffix
, 5)
6058 "_process_numa_parameters_of_flavor",
6059 new_callable
=CopyingMock(),
6061 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6062 def test_process_extended_config_of_flavor_with_numa_cpu_mem_vif_disk_quota(
6063 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6065 """Process extended config, extended has numas, cpu, mem, vif and disk-io quota."""
6067 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6068 {"memory": 2, "vcpu": [2]},
6072 "cpu-quota": {"limit": 3},
6073 "mem-quota": {"limit": 1},
6074 "vif-quota": {"limit": 10},
6075 "disk-io-quota": {"limit": 50},
6076 "mempage-size": "LARGE",
6079 expected_extra_specs
= {
6080 "hw:mem_page_size": "large",
6082 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6084 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6085 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6086 self
.assertEqual(extra_specs
, expected_extra_specs
)
6090 "_process_numa_parameters_of_flavor",
6091 new_callable
=CopyingMock(),
6093 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6094 def test_process_extended_config_of_flavor_with_numa_wrong_disk_quota(
6095 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6097 """Process extended config, extended has wrong disk quota key."""
6099 {"memory": 1, "threads": 3},
6100 {"memory": 2, "vcpu": [2]},
6104 "disk-quota": {"limit": 50},
6105 "mempage-size": "PREFER_LARGE",
6108 expected_extra_specs
= {
6109 "hw:mem_page_size": "any",
6111 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6112 mock_process_resource_quota
.assert_not_called()
6113 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6114 self
.assertEqual(extra_specs
, expected_extra_specs
)
6118 "_process_numa_parameters_of_flavor",
6119 new_callable
=CopyingMock(),
6121 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6122 def test_process_extended_config_of_flavor_without_numa_cpu_mem_vif_disk_quota(
6123 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6125 """Process extended config, extended has cpu, mem, vif and disk-io quota but not numas."""
6127 "cpu-quota": {"limit": 3},
6128 "mem-quota": {"limit": 1},
6129 "vif-quota": {"limit": 10},
6130 "disk-io-quota": {"limit": 50},
6131 "mempage-size": "SMALL",
6134 expected_extra_specs
= {
6135 "hw:mem_page_size": "small",
6137 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6138 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6139 mock_process_numa_parameters_of_flavor
.assert_not_called()
6140 self
.assertEqual(extra_specs
, expected_extra_specs
)
6144 "_process_numa_parameters_of_flavor",
6145 new_callable
=CopyingMock(),
6147 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6148 def test_process_extended_config_of_flavor_with_numa_with_cpu_pinning_mem_policy(
6149 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6151 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy."""
6154 {"memory": 2, "vcpu": [2]},
6158 "cpu-quota": {"limit": 3},
6159 "mem-quota": {"limit": 1},
6160 "mempage-size": "LARGE",
6161 "cpu-pinning-policy": "DEDICATED",
6162 "mem-policy": "STRICT",
6165 expected_extra_specs
= {
6166 "hw:mem_page_size": "large",
6167 "hw:cpu_policy": "dedicated",
6168 "hw:numa_mempolicy": "strict",
6170 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6171 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6172 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6173 self
.assertEqual(extra_specs
, expected_extra_specs
)
6177 "_process_numa_parameters_of_flavor",
6178 new_callable
=CopyingMock(),
6180 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6181 def test_process_extended_config_of_flavor_without_numa_with_cpu_pinning_mem_policy(
6182 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6184 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy but not numas."""
6186 "cpu-quota": {"limit": 3},
6187 "mem-quota": {"limit": 1},
6188 "mempage-size": "LARGE",
6189 "cpu-pinning-policy": "DEDICATED",
6190 "mem-policy": "STRICT",
6193 expected_extra_specs
= {
6194 "hw:mem_page_size": "large",
6195 "hw:cpu_policy": "dedicated",
6196 "hw:numa_mempolicy": "strict",
6198 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6199 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6200 mock_process_numa_parameters_of_flavor
.assert_not_called()
6201 self
.assertEqual(extra_specs
, expected_extra_specs
)
6205 "_process_numa_parameters_of_flavor",
6206 new_callable
=CopyingMock(),
6208 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6209 def test_process_extended_config_of_flavor_without_numa_with_wrong_mempage_size(
6210 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6212 """Process extended config, extended has wrong mempage-size without numas."""
6214 "cpu-quota": {"limit": 3},
6215 "mem-quota": {"limit": 1},
6216 "mempage-size": "SIZE_2GB",
6217 "cpu-pinning-policy": "DEDICATED",
6218 "mem-policy": "STRICT",
6222 expected_extra_specs
= {
6223 "hw:cpu_policy": "dedicated",
6224 "hw:numa_mempolicy": "strict",
6226 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6227 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6228 mock_process_numa_parameters_of_flavor
.assert_not_called()
6229 self
.assertEqual(extra_specs
, expected_extra_specs
)
6233 "_process_numa_parameters_of_flavor",
6234 new_callable
=CopyingMock(),
6236 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6237 def test_process_extended_config_of_flavor_with_numa_with_wrong_mempage_size(
6238 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6240 """Process extended config, extended has wrong mempage-size with numas."""
6243 {"memory": 2, "vcpu": [2]},
6247 "cpu-quota": {"limit": 3},
6248 "mem-quota": {"limit": 1},
6249 "mempage-size": "SIZE_2GB",
6250 "cpu-pinning-policy": "DEDICATED",
6251 "mem-policy": "STRICT",
6254 expected_extra_specs
= {
6255 "hw:cpu_policy": "dedicated",
6256 "hw:numa_mempolicy": "strict",
6258 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6259 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6260 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6261 self
.assertEqual(extra_specs
, expected_extra_specs
)
6265 "_process_numa_parameters_of_flavor",
6266 new_callable
=CopyingMock(),
6268 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6269 def test_process_extended_config_of_flavor_none_vcpus(
6270 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6272 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6275 {"memory": 2, "vcpu": [2]},
6279 "cpu-quota": {"limit": 3},
6280 "mem-quota": {"limit": 1},
6281 "mempage-size": "SIZE_2GB",
6282 "cpu-pinning-policy": "DEDICATED",
6283 "mem-policy": "STRICT",
6286 expected_extra_specs
= {
6287 "hw:cpu_policy": "dedicated",
6288 "hw:numa_mempolicy": "strict",
6290 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6291 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6292 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6293 self
.assertEqual(extra_specs
, expected_extra_specs
)
6297 "_process_numa_parameters_of_flavor",
6298 new_callable
=CopyingMock(),
6300 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6301 def test_process_extended_config_of_flavor_none_vcpus_without_numas(
6302 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6304 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6306 "cpu-quota": {"limit": 3},
6307 "mem-quota": {"limit": 1},
6308 "mempage-size": "SIZE_2GB",
6309 "cpu-pinning-policy": "DEDICATED",
6310 "mem-policy": "STRICT",
6312 extra_specs
= {"some-key": "some-val"}
6313 expected_extra_specs
= {
6314 "hw:cpu_policy": "dedicated",
6315 "hw:numa_mempolicy": "strict",
6316 "some-key": "some-val",
6318 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6319 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6320 mock_process_numa_parameters_of_flavor
.assert_not_called()
6321 self
.assertEqual(extra_specs
, expected_extra_specs
)
6325 "_process_numa_parameters_of_flavor",
6326 new_callable
=CopyingMock(),
6328 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6329 def test_process_extended_config_of_flavor_wrong_cpu_pinning_mem_policy_empty_vcpus(
6330 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6332 """Process extended config, extended has wrong cpu-pinning and mem-policy keys."""
6335 {"memory": 2, "vcpu": [2]},
6339 "cpu-quota": {"limit": 3},
6340 "mem-quota": {"limit": 1},
6341 "mempage-size": "SIZE_2GB",
6342 "cpu-pinning-pol": "DEDICATED",
6343 "mem-pol": "STRICT",
6346 expected_extra_specs
= {}
6347 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6348 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6349 mock_process_numa_parameters_of_flavor
.assert_called_once_with(
6352 self
.assertEqual(extra_specs
, expected_extra_specs
)
6356 "_process_numa_parameters_of_flavor",
6357 new_callable
=CopyingMock(),
6359 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6360 def test_process_extended_config_of_flavor_empty_extended(
6361 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6363 """Process extended config, extended is empty."""
6366 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6367 check_if_assert_not_called(
6368 [mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
]
6370 self
.assertEqual(extra_specs
, {})
6372 def test_get_flavor_details_empty_flavor_data(self
):
6374 expected_result
= (64, 1, {}, None)
6375 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6376 self
.assertEqual(result
, expected_result
)
6378 def test_get_flavor_details_flavor_data_has_ram_vcpus_extended(self
):
6383 "some-key": "some-val",
6386 expected_result
= (32, 3, {}, {"some-key": "some-val"})
6387 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6388 self
.assertEqual(result
, expected_result
)
6390 def test_get_flavor_details_flavor_data_is_none(self
):
6392 with self
.assertRaises(AttributeError):
6393 self
.vimconn
._get
_flavor
_details
(flavor_data
)
6395 def test_get_flavor_details_flavor_data_has_only_extended(self
):
6398 "some-key": "some-val",
6401 expected_result
= (64, 1, {}, {"some-key": "some-val"})
6402 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6403 self
.assertEqual(result
, expected_result
)
6405 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6408 "_process_extended_config_of_flavor",
6409 new_callable
=CopyingMock(),
6411 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6412 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6413 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6414 def test_new_flavor_with_extended_with_extra_specs(
6416 mock_format_exception
,
6417 mock_reload_connection
,
6418 mock_change_flavor_name
,
6419 mock_extended_config_of_flavor
,
6420 mock_get_flavor_details
,
6422 """Create new flavor with using extended parameters and extra specs."""
6425 mock_change_flavor_name
.return_value
= name1
6426 mock_get_flavor_details
.return_value
= (
6429 {"some-key": "some-value"},
6432 expected_result
= self
.new_flavor
.id
6433 result
= self
.vimconn
.new_flavor(flavor_data
)
6434 self
.assertEqual(result
, expected_result
)
6435 mock_reload_connection
.assert_called_once()
6436 self
.new_flavor
.set_keys
.assert_called_once()
6437 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6438 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6439 mock_extended_config_of_flavor
.assert_called_once_with(
6440 extended
, {"some-key": "some-value"}
6442 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6443 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6445 mock_format_exception
.assert_not_called()
6447 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6450 "_process_extended_config_of_flavor",
6451 new_callable
=CopyingMock(),
6453 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6454 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6455 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6456 def test_new_flavor_with_extended_without_extra_specs(
6458 mock_format_exception
,
6459 mock_reload_connection
,
6460 mock_change_flavor_name
,
6461 mock_extended_config_of_flavor
,
6462 mock_get_flavor_details
,
6464 """Create new flavor with using extended parameters without extra specs."""
6467 mock_change_flavor_name
.return_value
= name1
6468 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6469 expected_result
= self
.new_flavor
.id
6470 result
= self
.vimconn
.new_flavor(flavor_data
)
6471 self
.assertEqual(result
, expected_result
)
6472 mock_reload_connection
.assert_called_once()
6473 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6474 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6475 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6476 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6477 name
=name1
, ram
=3, vcpus
=vcpus
, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6479 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6481 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6484 "_process_extended_config_of_flavor",
6485 new_callable
=CopyingMock(),
6487 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6488 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6489 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6490 def test_new_flavor_change_name_if_used_false_with_extended(
6492 mock_format_exception
,
6493 mock_reload_connection
,
6494 mock_change_flavor_name
,
6495 mock_extended_config_of_flavor
,
6496 mock_get_flavor_details
,
6498 """Create new flavor, change_name_if_used_false, there is extended."""
6500 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6501 expected_result
= self
.new_flavor
.id
6502 result
= self
.vimconn
.new_flavor(flavor_data
, False)
6503 self
.assertEqual(result
, expected_result
)
6504 mock_reload_connection
.assert_called_once()
6505 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6506 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6507 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6508 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6510 check_if_assert_not_called(
6511 [mock_change_flavor_name
, mock_format_exception
, self
.new_flavor
.set_keys
]
6514 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6517 "_process_extended_config_of_flavor",
6518 new_callable
=CopyingMock(),
6520 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6521 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6522 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6523 def test_new_flavor_change_name_if_used_true_without_extended(
6525 mock_format_exception
,
6526 mock_reload_connection
,
6527 mock_change_flavor_name
,
6528 mock_extended_config_of_flavor
,
6529 mock_get_flavor_details
,
6531 """Create new flavor without extended parameters."""
6533 mock_change_flavor_name
.return_value
= name1
6534 expected_result
= self
.new_flavor
.id
6535 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6536 result
= self
.vimconn
.new_flavor(flavor_data2
)
6537 self
.assertEqual(result
, expected_result
)
6538 mock_reload_connection
.assert_called_once()
6539 mock_change_flavor_name
.assert_called_once_with(
6540 name1
, name_suffix
, flavor_data2
6542 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6543 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6544 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6546 check_if_assert_not_called(
6548 self
.new_flavor
.set_keys
,
6549 mock_extended_config_of_flavor
,
6550 mock_format_exception
,
6554 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6557 "_process_extended_config_of_flavor",
6558 new_callable
=CopyingMock(),
6560 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6561 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6562 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6563 def test_new_flavor_reload_connection_exception(
6565 mock_format_exception
,
6566 mock_reload_connection
,
6567 mock_change_flavor_name
,
6568 mock_extended_config_of_flavor
,
6569 mock_get_flavor_details
,
6571 """Create new flavor, reload connection exception occurred."""
6572 error_msg
= "Can not connect to client APIs."
6573 error
= nvExceptions
.ClientException(error_msg
)
6574 mock_change_flavor_name
.return_value
= name1
6575 mock_reload_connection
.side_effect
= error
6576 with self
.assertRaises(Exception) as err
:
6577 self
.vimconn
.new_flavor(flavor_data2
)
6578 self
.assertEqual(str(err
.exception
), "Can not connect to client APIs.")
6579 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6580 call_mock_format_exception
= mock_format_exception
.call_args
6582 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6584 check_if_assert_not_called(
6586 mock_change_flavor_name
,
6587 mock_get_flavor_details
,
6588 mock_extended_config_of_flavor
,
6589 self
.vimconn
.nova
.flavors
.create
,
6593 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6596 "_process_extended_config_of_flavor",
6597 new_callable
=CopyingMock(autospec
=True),
6599 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6600 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6601 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6602 def test_new_flavor_flavor_data_without_name(
6604 mock_format_exception
,
6605 mock_reload_connection
,
6606 mock_change_flavor_name
,
6607 mock_extended_config_of_flavor
,
6608 mock_get_flavor_details
,
6610 """Create new flavor, flavor data does not have name."""
6617 self
.vimconn
.new_flavor(flavor_data3
)
6618 mock_format_exception
.assert_called_once()
6619 call_mock_format_exception
= mock_format_exception
.call_args
6621 str(call_mock_format_exception
[0][0]), str(KeyError(error_msg
))
6623 check_if_assert_not_called(
6625 mock_reload_connection
,
6626 mock_change_flavor_name
,
6627 mock_get_flavor_details
,
6628 mock_extended_config_of_flavor
,
6629 self
.vimconn
.nova
.flavors
.create
,
6633 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6636 "_process_extended_config_of_flavor",
6637 new_callable
=CopyingMock(),
6639 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6640 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6641 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6642 def test_new_flavor_change_flavor_name_has_extended_conflict_exception_recovered_in_retry(
6644 mock_format_exception
,
6645 mock_reload_connection
,
6646 mock_change_flavor_name
,
6647 mock_extended_config_of_flavor
,
6648 mock_get_flavor_details
,
6650 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is extended config."""
6652 error_msg
= "Conflict has occurred while creating flavor name."
6653 error2
= nvExceptions
.Conflict(error_msg
)
6654 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6655 expected_result
= self
.new_flavor
.id
6656 mock_get_flavor_details
.return_value
= (3, 8, {}, extended
)
6657 result
= self
.vimconn
.new_flavor(flavor_data2
)
6658 self
.assertEqual(result
, expected_result
)
6659 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6660 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6661 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6662 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6663 self
.assertEqual(mock_extended_config_of_flavor
.call_count
, 1)
6664 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6665 name
="sample-flavor-3",
6673 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6675 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6678 "_process_extended_config_of_flavor",
6679 new_callable
=CopyingMock(),
6681 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6682 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6683 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6684 def test_new_flavor_change_flavor_name_without_extended_conflict_exception_recovered_in_retry(
6686 mock_format_exception
,
6687 mock_reload_connection
,
6688 mock_change_flavor_name
,
6689 mock_extended_config_of_flavor
,
6690 mock_get_flavor_details
,
6692 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is not extended config."""
6694 error2
= nvExceptions
.Conflict(
6695 "Conflict has occurred while creating flavor name."
6697 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6698 expected_result
= self
.new_flavor
.id
6699 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6700 result
= self
.vimconn
.new_flavor(flavor_data2
)
6701 self
.assertEqual(result
, expected_result
)
6702 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6703 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6704 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6705 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6706 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6707 name
="sample-flavor-3",
6715 check_if_assert_not_called(
6717 self
.new_flavor
.set_keys
,
6718 mock_extended_config_of_flavor
,
6719 mock_format_exception
,
6723 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6726 "_process_extended_config_of_flavor",
6727 new_callable
=CopyingMock(),
6729 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6730 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6731 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6732 def test_new_flavor_change_flavor_name_conflict_exception_change_name_if_used_false(
6734 mock_format_exception
,
6735 mock_reload_connection
,
6736 mock_change_flavor_name
,
6737 mock_extended_config_of_flavor
,
6738 mock_get_flavor_details
,
6740 """Create new flavor, nvExceptions.Conflict occurred,
6741 change_name_if_used is false."""
6742 change_name_if_used
= False
6743 error_msg
= "Conflict has occurred while creating flavor name."
6744 error2
= nvExceptions
.Conflict(error_msg
)
6745 mock_get_flavor_details
.return_value
= (4, 8, {}, None)
6746 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6747 with self
.assertRaises(Exception) as err
:
6748 self
.vimconn
.new_flavor(flavor_data2
, change_name_if_used
)
6749 self
.assertEqual(str(err
.exception
), error_msg
)
6750 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6751 self
.vimconn
.nova
.flavors
.create
.assert_called_with(
6752 name
="sample-flavor",
6760 self
.assertEqual(mock_get_flavor_details
.call_count
, 3)
6761 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6762 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6763 check_if_assert_not_called(
6764 [mock_change_flavor_name
, mock_extended_config_of_flavor
]
6766 _call_mock_format_exception
= mock_format_exception
.call_args
6768 str(_call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6770 self
.assertEqual(mock_format_exception
.call_count
, 3)
6772 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6775 "_process_extended_config_of_flavor",
6776 new_callable
=CopyingMock(),
6778 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6779 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6780 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6781 def test_new_flavor_client_exception_occurred_change_name_if_used_true(
6783 mock_format_exception
,
6784 mock_reload_connection
,
6785 mock_change_flavor_name
,
6786 mock_extended_config_of_flavor
,
6787 mock_get_flavor_details
,
6789 """Create new flavor, nvExceptions.ClientException occurred,
6790 change_name_if_used is true."""
6791 error_msg
= "Connection failed."
6792 error2
= nvExceptions
.ClientException(error_msg
)
6793 mock_change_flavor_name
.side_effect
= [
6798 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6799 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6800 with self
.assertRaises(Exception) as err
:
6801 self
.vimconn
.new_flavor(flavor_data2
)
6803 str(err
.exception
), "Conflict has occurred while creating flavor name."
6805 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6806 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 1)
6807 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6809 _call_mock_nova_create_flavor
[0][1],
6812 "name": "sample-flavor-3",
6823 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6824 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6825 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6827 _call_mock_change_flavor
[0][0],
6831 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6834 self
.assertEqual(mock_change_flavor_name
.call_count
, 1)
6835 mock_extended_config_of_flavor
.assert_not_called()
6836 call_mock_format_exception
= mock_format_exception
.call_args
6838 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6840 self
.assertEqual(mock_format_exception
.call_count
, 1)
6842 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6845 "_process_extended_config_of_flavor",
6846 new_callable
=CopyingMock(),
6848 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6849 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6850 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6851 def test_new_flavor_change_flavor_name_conflict_exception_occurred_change_name_if_used_true(
6853 mock_format_exception
,
6854 mock_reload_connection
,
6855 mock_change_flavor_name
,
6856 mock_extended_config_of_flavor
,
6857 mock_get_flavor_details
,
6859 """Create new flavor, nvExceptions.Conflict occurred,
6860 change_name_if_used is true."""
6861 error_msg
= "Conflict has occurred while creating flavor name."
6862 error2
= nvExceptions
.Conflict(error_msg
)
6863 mock_change_flavor_name
.side_effect
= [
6868 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6869 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6870 with self
.assertRaises(Exception) as err
:
6871 self
.vimconn
.new_flavor(flavor_data2
)
6872 self
.assertEqual(str(err
.exception
), error_msg
)
6873 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6874 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6875 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6877 _call_mock_nova_create_flavor
[0][1],
6880 "name": "sample-flavor-3",
6891 _call_mock_nova_create_flavor
[1][1],
6894 "name": "sample-flavor-4",
6905 _call_mock_nova_create_flavor
[2][1],
6908 "name": "sample-flavor-5",
6918 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6919 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6921 _call_mock_change_flavor
[0][0],
6925 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6929 _call_mock_change_flavor
[1][0],
6933 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6937 _call_mock_change_flavor
[2][0],
6941 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6944 self
.assertEqual(mock_change_flavor_name
.call_count
, 3)
6945 mock_extended_config_of_flavor
.assert_not_called()
6946 call_mock_format_exception
= mock_format_exception
.call_args
6948 str(call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6950 self
.assertEqual(mock_format_exception
.call_count
, 1)
6952 def test_process_process_vio_numa_nodes_without_numa_with_extra_spec(self
):
6954 extra_specs
= {"hw:numa_nodes": "0"}
6955 expected_extra_spec
= {
6956 "vmware:latency_sensitivity_level": "high",
6957 "hw:numa_nodes": "0",
6959 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6960 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6962 def test_process_process_vio_numa_nodes_list_type_numa_nodes_empty_extra_spec(self
):
6963 numa_nodes
= [7, 9, 4]
6965 expected_extra_spec
= {
6966 "vmware:latency_sensitivity_level": "high",
6968 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6969 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6971 def test_process_process_vio_numa_nodes_with_numa_with_extra_spec(self
):
6973 extra_specs
= {"hw:numa_nodes": "5"}
6974 expected_extra_spec
= {
6975 "vmware:latency_sensitivity_level": "high",
6976 "hw:numa_nodes": "5",
6978 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6979 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6981 def test_process_process_vio_numa_nodes_none_numa_nodes(self
):
6983 extra_specs
= {"hw:numa_nodes": "None"}
6984 expected_extra_spec
= {
6985 "vmware:latency_sensitivity_level": "high",
6986 "hw:numa_nodes": "None",
6988 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6989 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6991 def test_process_process_vio_numa_nodes_invalid_type_extra_specs(self
):
6994 with self
.assertRaises(TypeError):
6995 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6998 if __name__
== "__main__":