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 from mock
import MagicMock
, patch
31 from novaclient
import exceptions
as nvExceptions
32 from novaclient
.exceptions
import ClientException
, Conflict
33 from osm_ro_plugin
.vimconn
import (
34 VimConnConnectionException
,
36 VimConnNotFoundException
,
38 from osm_rovim_openstack
.vimconn_openstack
import vimconnector
40 __author__
= "Igor D.C."
41 __date__
= "$23-aug-2017 23:59:59$"
43 # Variables Used in TestNewVmInstance Class
45 description
= "my firewall"
47 image_id
= "408b73-e9cc-5a6a-t270-82cc4811bd4a"
48 flavor_id
= "208b73-e9cc-5a6a-t270-82cc4811bd4a"
49 affinity_group_list
= []
54 {"size": 10, "image_id": image_id
},
57 availability_zone_index
= 0
58 availability_zone_list
= ["nova"]
59 floating_network_vim_id
= "108b73-e9cc-5a6a-t270-82cc4811bd4a"
60 net_id
= "83372685-f67f-49fd-8722-eabb7692fc22"
61 net2_id
= "46472685-f67f-49fd-8722-eabb7692fc22"
62 mac_address
= "00:00:5e:00:53:af"
63 port_id
= "03372685-f67f-49fd-8722-eabb7692fc22"
64 time_return_value
= 156570000
65 port2_id
= "17472685-f67f-49fd-8722-eabb7692fc22"
66 root_vol_id
= "tc408b73-r9cc-5a6a-a270-82cc4811bd4a"
68 volume_id
= "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"
69 volume_id2
= "o4e0e83-b9uu-4akk-a234-89cc4811bd4a"
70 volume_id3
= "44e0e83-t9uu-4akk-a234-p9cc4811bd4a"
71 volume_id4
= "91bf5674-5b85-41d1-aa3b-4848e2691088"
72 virtual_mac_id
= "64e0e83-t9uu-4akk-a234-p9cc4811bd4a"
73 created_items_all_true
= {
74 f
"floating_ip:{floating_network_vim_id}": True,
75 f
"volume:{volume_id}": True,
76 f
"port:{port_id}": True,
80 # Variables used in TestNewFlavor Class
81 name1
= "sample-flavor"
84 "cpu-quota": {"limit": 3},
85 "mem-quota": {"limit": 1},
86 "mempage-size": "LARGE",
87 "cpu-pinning-policy": "DEDICATED",
88 "mem-policy": "STRICT",
107 def check_if_assert_not_called(mocks
: list):
108 for mocking
in mocks
:
109 mocking
.assert_not_called()
113 def __init__(self
, s
, type="__DEFAULT__", name
="", id=""):
115 self
.volume_type
= type
120 class CopyingMock(MagicMock
):
121 def __call__(self
, *args
, **kwargs
):
122 args
= deepcopy(args
)
123 kwargs
= deepcopy(kwargs
)
124 return super(CopyingMock
, self
).__call
__(*args
, **kwargs
)
127 class TestNewVmInstance(unittest
.TestCase
):
128 @patch("logging.getLogger", autospec
=True)
129 def setUp(self
, mock_logger
):
130 # Instantiate dummy VIM connector so we can test it
131 # It throws exception because of dummy parameters,
132 # We are disabling the logging of exception not to print them to console.
133 mock_logger
= logging
.getLogger()
134 mock_logger
.disabled
= True
135 self
.vimconn
= vimconnector(
145 self
.vimconn
.neutron
= CopyingMock()
146 self
.vimconn
.nova
= CopyingMock()
147 self
.vimconn
.cinder
= CopyingMock()
148 self
.server
= MagicMock(object, autospec
=True)
149 self
.server
.tenant_id
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
150 self
.server
.id = "908b73-e9cc-5a6a-t270-82cc4811bd4a"
151 self
.vimconn
.config
["security_groups"] = "default"
152 self
.vimconn
.config
["keypair"] = "my_keypair"
153 self
.vimconn
.security_groups_id
= "12345"
154 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.32"
155 self
.vimconn
.logger
= CopyingMock()
157 @patch.object(vimconnector
, "_get_ids_from_name")
158 def test_prepare_port_dict_security_security_groups_exists_in_config(
161 """In VIM config security_groups exists, net port_security is True
162 no_port_security_extension does not exist.
164 self
.vimconn
.config
= {"security_groups": "example_security_group"}
165 net
= {"port_security": True}
167 result_dict
= {"security_groups": "12345"}
169 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
170 self
.assertDictEqual(result_dict
, port_dict
)
171 mock_get_ids
.assert_not_called()
173 @patch.object(vimconnector
, "_get_ids_from_name")
174 def test_prepare_port_dict_security_security_groups_exists_in_config_no_security_groups_id(
177 """In VIM config Security_groups exists, net port_security is True, vim security_groups_id does not exist,
178 no_port_security_extension does not exist.
180 self
.vimconn
.config
= {"security_groups": "example_security_group"}
181 self
.vimconn
.security_groups_id
= None
182 net
= {"port_security": True}
184 result_dict
= {"security_groups": None}
186 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
187 self
.assertDictEqual(result_dict
, port_dict
)
188 mock_get_ids
.assert_called()
190 @patch.object(vimconnector
, "_get_ids_from_name")
191 def test_prepare_port_dict_security_security_groups_exists_security_extension_true_in_config(
194 """In VIM config security_groups exists, net port_security is True, in VIM security_groups_id exists,
195 no_port_security_extension set to True.
197 self
.vimconn
.config
= {
198 "security_groups": "example_security_group",
199 "no_port_security_extension": True,
201 net
= {"port_security": True}
205 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
206 self
.assertDictEqual(result_dict
, port_dict
)
207 mock_get_ids
.assert_not_called()
209 @patch.object(vimconnector
, "_get_ids_from_name")
210 def test_prepare_port_dict_security_no_security_groups_in_config(
213 """In VIM config security_group does not exist, net port_security True, in VIM security_groups_id exists,
214 no_port_security_extension does not exist."""
215 self
.vimconn
.config
= {}
216 net
= {"port_security": True}
220 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
221 self
.assertDictEqual(result_dict
, port_dict
)
222 mock_get_ids
.assert_not_called()
224 @patch.object(vimconnector
, "_get_ids_from_name")
225 def test_prepare_port_dict_security_no_security_groups_security_extension_true_in_config(
228 """Security_group does not exist, net port_security is True, in VIM security_groups_id exists,
229 no_port_security_extension set to True."""
230 self
.vimconn
.config
= {"no_port_security_extension": True}
231 net
= {"port_security": True}
235 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
236 self
.assertDictEqual(result_dict
, port_dict
)
237 mock_get_ids
.assert_not_called()
239 @patch.object(vimconnector
, "_get_ids_from_name")
240 def test_prepare_port_dict_security_security_groups_exists_net_port_security_false(
243 """In VIM config security_group exists, net port_security False, security_groups_id exists,
244 no_port_security_extension does not exist."""
245 self
.vimconn
.config
= {"security_groups": "example_security_group"}
246 net
= {"port_security": False}
250 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
251 self
.assertDictEqual(result_dict
, port_dict
)
252 mock_get_ids
.assert_not_called()
254 @patch.object(vimconnector
, "_get_ids_from_name")
255 def test_prepare_port_dict_security_net_port_security_false_port_security_extension_true(
258 """In VIM config security_group exists, net port_security False, security_groups_id exists,
259 no_port_security_extension set to True."""
260 self
.vimconn
.config
= {
261 "security_groups": "example_security_group",
262 "no_port_security_extension": True,
264 net
= {"port_security": False}
268 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
269 self
.assertDictEqual(result_dict
, port_dict
)
270 mock_get_ids
.assert_not_called()
272 def test_prepare_port_dict_binding_net_type_virtual(self
):
273 """net type is virtual."""
274 net
= {"type": "virtual"}
277 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
278 self
.assertDictEqual(result_dict
, port_dict
)
280 def test_prepare_port_dict_binding_net_type_vf(self
):
281 """net type is VF, vim_type is not VIO."""
283 self
.vimconn
.vim_type
= None
285 result_dict
= {"binding:vnic_type": "direct"}
286 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
287 self
.assertDictEqual(port_dict
, result_dict
)
289 def test_prepare_port_dict_binding_net_type_sriov_vim_type_vio(self
):
290 """net type is SR-IOV, vim_type is VIO."""
291 net
= {"type": "SR-IOV"}
292 self
.vimconn
.vim_type
= "VIO"
295 "binding:vnic_type": "direct",
296 "port_security_enabled": False,
297 "provider_security_groups": [],
298 "security_groups": [],
300 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
301 self
.assertDictEqual(port_dict
, result_dict
)
303 def test_prepare_port_dict_binding_net_type_passthrough(self
):
304 """net type is pci-passthrough."""
305 net
= {"type": "PCI-PASSTHROUGH"}
308 "binding:vnic_type": "direct-physical",
310 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
311 self
.assertDictEqual(port_dict
, result_dict
)
313 def test_prepare_port_dict_binding_no_net_type(self
):
314 """net type is missing."""
317 with self
.assertRaises(VimConnException
) as err
:
318 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
319 self
.assertEqual(str(err
.exception
), "Type is missing in the network details.")
321 def test_set_fixed_ip(self
):
322 """new_port has fixed ip."""
326 "fixed_ips": [{"ip_address": "10.1.2.3"}, {"ip_address": "20.1.2.3"}]
329 result
= {"ip": "10.1.2.3"}
330 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
331 self
.assertDictEqual(net
, result
)
333 def test_set_fixed_ip_no_fixed_ip(self
):
334 """new_port does not have fixed ip."""
336 new_port
= {"port": {}}
337 result
= {"ip": None}
338 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
339 self
.assertDictEqual(net
, result
)
341 def test_set_fixed_ip_raise_exception(self
):
342 """new_port does not have port details."""
345 with self
.assertRaises(Exception) as err
:
346 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
347 self
.assertEqual(type(err
.exception
), KeyError)
349 def test_prepare_port_dict_mac_ip_addr(self
):
350 """mac address and ip address exist."""
352 "mac_address": mac_address
,
353 "ip_address": "10.0.1.5",
357 "mac_address": mac_address
,
358 "fixed_ips": [{"ip_address": "10.0.1.5"}],
360 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
361 self
.assertDictEqual(port_dict
, result_dict
)
363 def test_prepare_port_dict_mac_ip_addr_empty_net(self
):
364 """mac address and ip address does not exist."""
368 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
369 self
.assertDictEqual(port_dict
, result_dict
)
371 def test_prepare_port_dict_mac_ip_addr_dual(self
):
372 """mac address, ipv4 and ipv6 addresses exist."""
374 "mac_address": mac_address
,
375 "ip_address": ["10.0.1.5", "2345:0425:2CA1:0000:0000:0567:5673:23b5"],
379 "mac_address": mac_address
,
381 {"ip_address": "10.0.1.5"},
382 {"ip_address": "2345:0425:2CA1:0000:0000:0567:5673:23b5"},
385 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
386 self
.assertDictEqual(port_dict
, result_dict
)
388 def test_prepare_port_dict_mac_ip_addr_dual_ip_addr_is_not_list(self
):
389 """mac address, ipv4 and ipv6 addresses exist."""
391 "mac_address": mac_address
,
392 "ip_address": "10.0.1.5",
396 "mac_address": mac_address
,
398 {"ip_address": "10.0.1.5"},
401 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
402 self
.assertDictEqual(port_dict
, result_dict
)
404 def test_prepare_port_dict_mac_ip_addr_dual_net_without_ip_addr(self
):
405 """mac address, ipv4 and ipv6 addresses exist."""
407 "mac_address": mac_address
,
412 "mac_address": mac_address
,
414 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
415 self
.assertDictEqual(port_dict
, result_dict
)
417 def test_prepare_port_dict_mac_ip_addr_dual_net_without_mac_addr(self
):
418 """mac address, ipv4 and ipv6 addresses exist."""
420 "ip_address": ["10.0.1.5", "2345:0425:2CA1:0000:0000:0567:5673:23b5"],
425 {"ip_address": "10.0.1.5"},
426 {"ip_address": "2345:0425:2CA1:0000:0000:0567:5673:23b5"},
429 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
430 self
.assertDictEqual(port_dict
, result_dict
)
432 def test_create_new_port(self
):
433 """new port has id and mac address."""
437 "mac_address": mac_address
,
440 self
.vimconn
.neutron
.create_port
.return_value
= new_port
441 net
, port_dict
, created_items
= {}, {}, {}
442 expected_result
= new_port
444 "mac_address": mac_address
,
447 expected_created_items
= {f
"port:{port_id}": True}
448 result
= self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
449 self
.assertDictEqual(result
, expected_result
)
450 self
.assertEqual(net
, expected_net
)
451 self
.assertEqual(created_items
, expected_created_items
)
452 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
454 def test_create_new_port_without_mac_or_id(self
):
455 """new port does not have mac address or ID."""
457 self
.vimconn
.neutron
.create_port
.return_value
= new_port
458 net
, port_dict
, created_items
= {}, {}, {}
459 with self
.assertRaises(KeyError):
460 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
461 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
463 def test_create_new_port_neutron_create_port_raises_exception(self
):
464 """Neutron create port raises exception."""
465 self
.vimconn
.neutron
.create_port
.side_effect
= VimConnException(
466 "New port is not created."
468 net
, port_dict
, created_items
= {}, {}, {}
469 with self
.assertRaises(VimConnException
):
470 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
471 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
473 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
474 @patch.object(vimconnector
, "_prepare_port_dict_binding")
475 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
476 @patch.object(vimconnector
, "_create_new_port")
477 @patch.object(vimconnector
, "_set_fixed_ip")
478 def test_create_port(
481 mock_create_new_port
,
482 mock_prepare_port_dict_mac_ip_addr
,
483 mock_prepare_port_dict_binding
,
484 mock_prepare_port_dict_security_groups
,
486 """Net has name, type, net-id."""
490 "name": "management",
497 "mac_address": mac_address
,
498 "name": "management",
499 "fixed_ips": [{"ip_address": ip_addr1
}],
502 mock_create_new_port
.return_value
= new_port
508 "network_id": net_id
,
509 "name": "management",
510 "admin_state_up": True,
513 new_port_result
, port_result
= self
.vimconn
._create
_port
(
514 net
, name
, created_items
517 self
.assertDictEqual(new_port_result
, new_port
)
518 self
.assertDictEqual(port_result
, expected_port
)
520 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
521 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
522 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
523 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
524 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
526 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
527 @patch.object(vimconnector
, "_prepare_port_dict_binding")
528 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
529 @patch.object(vimconnector
, "_create_new_port")
530 @patch.object(vimconnector
, "_set_fixed_ip")
531 def test_create_port_no_port_name(
534 mock_create_new_port
,
535 mock_prepare_port_dict_mac_ip_addr
,
536 mock_prepare_port_dict_binding
,
537 mock_prepare_port_dict_security_groups
,
539 """Net has no name."""
548 "mac_address": mac_address
,
550 "fixed_ips": [{"ip_address": ip_addr1
}],
553 mock_create_new_port
.return_value
= new_port
559 "network_id": net_id
,
560 "admin_state_up": True,
564 new_port_result
, port_result
= self
.vimconn
._create
_port
(
565 net
, name
, created_items
568 self
.assertDictEqual(new_port_result
, new_port
)
569 self
.assertDictEqual(port_result
, expected_port
)
571 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
572 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
573 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
574 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
575 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
577 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
578 @patch.object(vimconnector
, "_prepare_port_dict_binding")
579 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
580 @patch.object(vimconnector
, "_create_new_port")
581 @patch.object(vimconnector
, "_set_fixed_ip")
582 def test_create_port_nova_api_version_smaller_than_232(
585 mock_create_new_port
,
586 mock_prepare_port_dict_mac_ip_addr
,
587 mock_prepare_port_dict_binding
,
588 mock_prepare_port_dict_security_groups
,
590 """Nova api version is smaller than 2.32."""
591 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.30"
600 "mac_address": mac_address
,
602 "fixed_ips": [{"ip_address": ip_addr1
}],
605 mock_create_new_port
.return_value
= new_port
610 "network_id": net_id
,
611 "admin_state_up": True,
615 new_port_result
, port_result
= self
.vimconn
._create
_port
(
616 net
, name
, created_items
619 self
.assertDictEqual(new_port_result
, new_port
)
620 self
.assertDictEqual(port_result
, expected_port
)
622 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
623 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
624 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
625 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
626 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
628 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
629 @patch.object(vimconnector
, "_prepare_port_dict_binding")
630 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
631 @patch.object(vimconnector
, "_create_new_port")
632 @patch.object(vimconnector
, "_set_fixed_ip")
633 def test_create_port_create_new_port_raise_exception(
636 mock_create_new_port
,
637 mock_prepare_port_dict_mac_ip_addr
,
638 mock_prepare_port_dict_binding
,
639 mock_prepare_port_dict_security_groups
,
641 """_create_new_port method raises exception."""
647 mock_create_new_port
.side_effect
= Exception
649 "network_id": net_id
,
650 "admin_state_up": True,
654 with self
.assertRaises(Exception):
655 self
.vimconn
._create
_port
(net
, name
, created_items
)
657 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
658 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
659 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
660 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
661 mock_set_fixed_ip
.assert_not_called()
663 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
664 @patch.object(vimconnector
, "_prepare_port_dict_binding")
665 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
666 @patch.object(vimconnector
, "_create_new_port")
667 @patch.object(vimconnector
, "_set_fixed_ip")
668 def test_create_port_create_sec_groups_raises_exception(
671 mock_create_new_port
,
672 mock_prepare_port_dict_mac_ip_addr
,
673 mock_prepare_port_dict_binding
,
674 mock_prepare_port_dict_security_groups
,
676 """_prepare_port_dict_security_groups method raises exception."""
682 mock_prepare_port_dict_security_groups
.side_effect
= Exception
684 "network_id": net_id
,
685 "admin_state_up": True,
689 with self
.assertRaises(Exception):
690 self
.vimconn
._create
_port
(net
, name
, created_items
)
692 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
694 mock_prepare_port_dict_binding
.assert_not_called()
695 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
696 mock_create_new_port
.assert_not_called()
697 mock_set_fixed_ip
.assert_not_called()
699 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
700 @patch.object(vimconnector
, "_prepare_port_dict_binding")
701 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
702 @patch.object(vimconnector
, "_create_new_port")
703 @patch.object(vimconnector
, "_set_fixed_ip")
704 def test_create_port_create_port_dict_binding_raise_exception(
707 mock_create_new_port
,
708 mock_prepare_port_dict_mac_ip_addr
,
709 mock_prepare_port_dict_binding
,
710 mock_prepare_port_dict_security_groups
,
712 """_prepare_port_dict_binding method raises exception."""
719 mock_prepare_port_dict_binding
.side_effect
= Exception
721 "network_id": net_id
,
722 "admin_state_up": True,
726 with self
.assertRaises(Exception):
727 self
.vimconn
._create
_port
(net
, name
, created_items
)
729 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
731 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
733 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
734 mock_create_new_port
.assert_not_called()
735 mock_set_fixed_ip
.assert_not_called()
737 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
738 @patch.object(vimconnector
, "_prepare_port_dict_binding")
739 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
740 @patch.object(vimconnector
, "_create_new_port")
741 @patch.object(vimconnector
, "_set_fixed_ip")
742 def test_create_port_create_port_mac_ip_addr_raise_exception(
745 mock_create_new_port
,
746 mock_prepare_port_dict_mac_ip_addr
,
747 mock_prepare_port_dict_binding
,
748 mock_prepare_port_dict_security_groups
,
750 """prepare_port_dict_mac_ip_addr method raises exception."""
756 mock_prepare_port_dict_mac_ip_addr
.side_effect
= Exception
758 "network_id": net_id
,
759 "admin_state_up": True,
763 with self
.assertRaises(Exception):
764 self
.vimconn
._create
_port
(net
, name
, created_items
)
766 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
767 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
768 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
770 mock_create_new_port
.assert_not_called()
771 mock_set_fixed_ip
.assert_not_called()
773 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
774 @patch.object(vimconnector
, "_prepare_port_dict_binding")
775 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
776 @patch.object(vimconnector
, "_create_new_port")
777 @patch.object(vimconnector
, "_set_fixed_ip")
778 def test_create_port_create_port_set_fixed_ip_raise_exception(
781 mock_create_new_port
,
782 mock_prepare_port_dict_mac_ip_addr
,
783 mock_prepare_port_dict_binding
,
784 mock_prepare_port_dict_security_groups
,
786 """_set_fixed_ip method raises exception."""
792 mock_set_fixed_ip
.side_effect
= VimConnException(
793 "Port detail is missing in new_port."
796 "network_id": net_id
,
797 "admin_state_up": True,
803 "mac_address": mac_address
,
805 "fixed_ips": [{"ip_address": ip_addr1
}],
808 mock_create_new_port
.return_value
= new_port
810 with self
.assertRaises(VimConnException
):
811 self
.vimconn
._create
_port
(net
, name
, created_items
)
813 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
814 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
815 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
816 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
817 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
819 @patch.object(vimconnector
, "_reload_connection")
820 @patch.object(vimconnector
, "_create_port")
821 def test_prepare_network_for_vm_instance_no_net_id(
822 self
, mock_create_port
, mock_reload_connection
824 """Nets do not have net_id"""
825 mock_reload_connection
.side_effect
= None
830 "port_security": False,
831 "exit_on_floating_ip_error": False,
832 "port_security_disable_strategy": "full",
835 "port_security": True,
836 "exit_on_floating_ip_error": False,
841 external_network
, no_secured_ports
= [], []
842 expected_external_network
, expected_no_secured_ports
= [], []
843 expected_net_list_vim
= []
845 self
.vimconn
._prepare
_network
_for
_vminstance
(
853 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
854 self
.assertEqual(external_network
, expected_external_network
)
855 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
857 mock_create_port
.assert_not_called()
859 @patch.object(vimconnector
, "_reload_connection")
860 @patch.object(vimconnector
, "_create_port")
861 def test_prepare_network_for_vm_instance_empty_net_list(
862 self
, mock_create_port
, mock_reload_connection
864 """Net list is empty."""
865 mock_reload_connection
.side_effect
= None
868 external_network
, no_secured_ports
= [], []
869 expected_external_network
, expected_no_secured_ports
= [], []
870 expected_net_list_vim
= []
872 self
.vimconn
._prepare
_network
_for
_vminstance
(
880 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
881 self
.assertEqual(external_network
, expected_external_network
)
882 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
884 mock_create_port
.assert_not_called()
886 @patch.object(vimconnector
, "_reload_connection")
887 @patch.object(vimconnector
, "_create_port")
888 def test_prepare_network_for_vm_instance_use_floating_ip_false_mgmt_net(
889 self
, mock_create_port
, mock_reload_connection
891 """Nets have net-id, floating_ip False, mgmt network."""
892 mock_reload_connection
.side_effect
= None
897 "floating_ip": False,
902 mock_create_port
.side_effect
= [
907 "mac_address": mac_address
,
911 {"port-dict": port2_id
},
914 external_network
, no_secured_ports
= [], []
915 expected_external_network
, expected_no_secured_ports
= [], []
916 expected_net_list_vim
= [{"port-dict": port2_id
}]
917 self
.vimconn
._prepare
_network
_for
_vminstance
(
925 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
926 self
.assertEqual(external_network
, expected_external_network
)
927 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
929 mock_create_port
.assert_called_once_with(
932 "floating_ip": False,
939 @patch.object(vimconnector
, "_reload_connection")
940 def test_prepare_network_for_vm_instance_mgmt_net_net_port_security_and_floating_ip_true(
941 self
, mock_reload_connection
943 """Nets have net-id, use_floating_ip False in VIM config, mgmt network, net floating_ip is True."""
944 self
.vimconn
.config
["use_floating_ip"] = False
945 mock_create_port
= CopyingMock()
946 mock_reload_connection
.side_effect
= None
956 mock_create_port
.side_effect
= [
961 "mac_address": mac_address
,
965 {"port-dict": port2_id
},
968 external_network
, no_secured_ports
= [], []
969 expected_external_network
= [
974 "exit_on_floating_ip_error": True,
977 expected_no_secured_ports
= []
978 expected_net_list_vim
= [{"port-dict": port2_id
}]
979 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
980 self
.vimconn
._prepare
_network
_for
_vminstance
(
988 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
989 self
.assertEqual(external_network
, expected_external_network
)
990 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
992 mock_create_port
.assert_called_once_with(
1002 @patch.object(vimconnector
, "_reload_connection")
1003 def test_prepare_network_for_vm_instance_use_floating_ip_true_mgmt_net_port_security_false(
1004 self
, mock_reload_connection
1006 """Nets have net-id, use_floating_ip is True in VIM config, mgmt network, net port security is False."""
1007 mock_create_port
= CopyingMock()
1008 self
.vimconn
.config
["use_floating_ip"] = True
1009 self
.vimconn
.config
["no_port_security_extension"] = False
1010 mock_reload_connection
.side_effect
= None
1017 "port_security": False,
1018 "exit_on_floating_ip_error": False,
1019 "port_security_disable_strategy": "full",
1023 mock_create_port
.side_effect
= [
1028 "mac_address": mac_address
,
1032 {"port-dict": port2_id
},
1035 external_network
, no_secured_ports
= [], []
1036 expected_external_network
= [
1040 "port_security": False,
1041 "exit_on_floating_ip_error": False,
1042 "port_security_disable_strategy": "full",
1043 "floating_ip": True,
1046 expected_no_secured_ports
= [(port2_id
, "full")]
1047 expected_net_list_vim
= [{"port-dict": port2_id
}]
1048 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1049 self
.vimconn
._prepare
_network
_for
_vminstance
(
1058 mock_create_port
.assert_called_once_with(
1062 "port_security": False,
1063 "exit_on_floating_ip_error": False,
1064 "port_security_disable_strategy": "full",
1069 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1070 self
.assertEqual(external_network
, expected_external_network
)
1071 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1073 @patch.object(vimconnector
, "_reload_connection")
1074 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_false(
1075 self
, mock_reload_connection
1077 """Nets have net-id, use_floating_ip True in VIM config, non-mgmt network, port security is False."""
1078 mock_create_port
= CopyingMock()
1079 self
.vimconn
.config
["use_floating_ip"] = True
1080 self
.vimconn
.config
["no_port_security_extension"] = False
1081 mock_reload_connection
.side_effect
= None
1088 "port_security": False,
1089 "port_security_disable_strategy": "full",
1093 mock_create_port
.side_effect
= [
1098 "mac_address": mac_address
,
1102 {"port-dict": port2_id
},
1105 external_network
, no_secured_ports
= [], []
1106 expected_external_network
= []
1107 expected_no_secured_ports
= [(port2_id
, "full")]
1108 expected_net_list_vim
= [{"port-dict": port2_id
}]
1109 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1110 self
.vimconn
._prepare
_network
_for
_vminstance
(
1119 mock_create_port
.assert_called_once_with(
1123 "port_security": False,
1124 "port_security_disable_strategy": "full",
1129 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1130 self
.assertEqual(external_network
, expected_external_network
)
1131 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1133 @patch.object(vimconnector
, "_reload_connection")
1134 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_true(
1135 self
, mock_reload_connection
1137 """Nets have net-id, use_floating_ip is True in VIM config, non-mgmt network, net port security is True."""
1138 mock_create_port
= CopyingMock()
1139 self
.vimconn
.config
["use_floating_ip"] = True
1140 self
.vimconn
.config
["no_port_security_extension"] = True
1141 mock_reload_connection
.side_effect
= None
1148 "port_security": True,
1149 "port_security_disable_strategy": "full",
1153 mock_create_port
.side_effect
= [
1158 "mac_address": mac_address
,
1162 {"port-dict": port2_id
},
1165 external_network
, no_secured_ports
= [], []
1166 expected_external_network
= []
1167 expected_no_secured_ports
= []
1168 expected_net_list_vim
= [{"port-dict": port2_id
}]
1169 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1170 self
.vimconn
._prepare
_network
_for
_vminstance
(
1179 mock_create_port
.assert_called_once_with(
1183 "port_security": True,
1184 "port_security_disable_strategy": "full",
1189 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1190 self
.assertEqual(external_network
, expected_external_network
)
1191 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1193 @patch.object(vimconnector
, "_reload_connection")
1194 def test_prepare_network_for_vm_instance_create_port_raise_exception(
1195 self
, mock_reload_connection
1197 """_create_port method raise exception."""
1198 mock_create_port
= CopyingMock()
1199 self
.vimconn
.config
["use_floating_ip"] = True
1200 self
.vimconn
.config
["no_port_security_extension"] = True
1201 mock_reload_connection
.side_effect
= None
1208 "port_security": True,
1209 "port_security_disable_strategy": "full",
1213 mock_create_port
.side_effect
= KeyError
1214 external_network
, no_secured_ports
= [], []
1215 expected_external_network
= []
1216 expected_no_secured_ports
= []
1217 expected_net_list_vim
= []
1218 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1219 with self
.assertRaises(Exception) as err
:
1220 self
.vimconn
._prepare
_network
_for
_vminstance
(
1229 self
.assertEqual(type(err
.exception
), KeyError)
1231 mock_create_port
.assert_called_once_with(
1235 "port_security": True,
1236 "port_security_disable_strategy": "full",
1241 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1242 self
.assertEqual(external_network
, expected_external_network
)
1243 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1245 @patch.object(vimconnector
, "_reload_connection")
1246 def test_prepare_network_for_vm_instance_reload_connection_raise_exception(
1247 self
, mock_reload_connection
1249 """_reload_connection method raises exception."""
1250 mock_create_port
= CopyingMock()
1251 mock_reload_connection
.side_effect
= VimConnConnectionException(
1252 "Connection failed."
1254 self
.vimconn
.config
["use_floating_ip"] = True
1255 self
.vimconn
.config
["no_port_security_extension"] = True
1262 "port_security": True,
1263 "port_security_disable_strategy": "full",
1267 mock_create_port
.side_effect
= None
1268 external_network
, no_secured_ports
= [], []
1269 expected_external_network
= []
1270 expected_no_secured_ports
= []
1271 expected_net_list_vim
= []
1272 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1273 with self
.assertRaises(Exception) as err
:
1274 self
.vimconn
._prepare
_network
_for
_vminstance
(
1283 self
.assertEqual(type(err
.exception
), VimConnConnectionException
)
1284 self
.assertEqual(str(err
.exception
), "Connection failed.")
1285 mock_reload_connection
.assert_called_once()
1286 mock_create_port
.assert_not_called()
1287 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1288 self
.assertEqual(external_network
, expected_external_network
)
1289 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1291 def test_prepare_persistent_root_volumes_vim_using_volume_id(self
):
1292 """Existing persistent root volume with vim_volume_id."""
1293 vm_av_zone
= ["nova"]
1294 base_disk_index
= ord("a")
1295 disk
= {"vim_volume_id": volume_id
}
1296 block_device_mapping
= {}
1297 existing_vim_volumes
= []
1299 expected_boot_vol_id
= None
1300 expected_block_device_mapping
= {"vda": volume_id
}
1301 expected_existing_vim_volumes
= [{"id": volume_id
}]
1302 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1307 block_device_mapping
,
1308 existing_vim_volumes
,
1311 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1312 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1313 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1314 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1316 @patch.object(vimconnector
, "update_block_device_mapping")
1317 def test__prepare_shared_volumes_vim_using_volume_id(
1318 self
, mock_update_block_device_mapping
1320 """Existing persistent non root volume with vim_volume_id.
1322 def __init__(self, s, type="__DEFAULT__", name="", id=""):
1324 self.volume_type = type
1327 volumes = {"shared-volume": volume_id4}
1329 The device mappeing BEFORE is: {}
1330 The device mappeing AFTER is: {'vdb': '8ca50cc6-a779-4513-a1f3-900b8b3987d2'}
1332 base_disk_index
= ord("b")
1333 disk
= {"name": "shared-volume"}
1334 block_device_mapping
= {}
1335 existing_vim_volumes
= []
1337 expected_block_device_mapping
= {}
1338 self
.vimconn
.cinder
.volumes
.list.return_value
= [
1339 Volume("avaible", "multiattach", "shared-volume", volume_id4
)
1341 self
.vimconn
.cinder
.volumes
.get
.return_value
.id = volume_id4
1342 self
.vimconn
._prepare
_shared
_volumes
(
1346 block_device_mapping
,
1347 existing_vim_volumes
,
1350 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id4
)
1351 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1353 @patch.object(vimconnector
, "update_block_device_mapping")
1354 def test_prepare_persistent_non_root_volumes_vim_using_volume_id(
1355 self
, mock_update_block_device_mapping
1357 """Existing persistent non root volume with vim_volume_id."""
1358 vm_av_zone
= ["nova"]
1359 base_disk_index
= ord("b")
1360 disk
= {"vim_volume_id": volume_id
}
1361 block_device_mapping
= {}
1362 existing_vim_volumes
= []
1364 expected_block_device_mapping
= {"vdb": volume_id
}
1365 expected_existing_vim_volumes
= [{"id": volume_id
}]
1366 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1370 block_device_mapping
,
1372 existing_vim_volumes
,
1375 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1376 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1377 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1378 mock_update_block_device_mapping
.assert_not_called()
1380 @patch.object(vimconnector
, "update_block_device_mapping")
1381 def test_prepare_persistent_root_volumes_using_vim_id(
1382 self
, mock_update_block_device_mapping
1384 """Existing persistent root volume with vim_id."""
1385 vm_av_zone
= ["nova"]
1386 base_disk_index
= ord("a")
1387 disk
= {"vim_id": volume_id
}
1388 block_device_mapping
= {}
1389 existing_vim_volumes
= []
1391 expected_boot_vol_id
= None
1392 expected_block_device_mapping
= {"vda": volume_id
}
1393 expected_existing_vim_volumes
= [{"id": volume_id
}]
1394 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1399 block_device_mapping
,
1400 existing_vim_volumes
,
1403 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1404 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1405 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1406 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1407 mock_update_block_device_mapping
.assert_not_called()
1409 @patch.object(vimconnector
, "update_block_device_mapping")
1410 def test_prepare_persistent_non_root_volumes_using_vim_id(
1411 self
, mock_update_block_device_mapping
1413 """Existing persistent root volume with vim_id."""
1414 vm_av_zone
= ["nova"]
1415 base_disk_index
= ord("b")
1416 disk
= {"vim_id": volume_id
}
1417 block_device_mapping
= {}
1418 existing_vim_volumes
= []
1421 expected_block_device_mapping
= {"vdb": volume_id
}
1422 expected_existing_vim_volumes
= [{"id": volume_id
}]
1423 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1427 block_device_mapping
,
1429 existing_vim_volumes
,
1433 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1434 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1435 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1436 mock_update_block_device_mapping
.assert_not_called()
1438 @patch.object(vimconnector
, "update_block_device_mapping")
1439 def test_prepare_persistent_root_volumes_create(
1440 self
, mock_update_block_device_mapping
1442 """Create persistent root volume."""
1443 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1444 vm_av_zone
= ["nova"]
1445 base_disk_index
= ord("a")
1446 disk
= {"size": 10, "image_id": image_id
}
1447 block_device_mapping
= {}
1448 existing_vim_volumes
= []
1450 expected_boot_vol_id
= volume_id2
1451 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1456 block_device_mapping
,
1457 existing_vim_volumes
,
1460 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1461 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1465 availability_zone
=["nova"],
1467 mock_update_block_device_mapping
.assert_called_once()
1468 _call_mock_update_block_device_mapping
= (
1469 mock_update_block_device_mapping
.call_args_list
1472 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1473 block_device_mapping
,
1476 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1478 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1480 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1483 @patch.object(vimconnector
, "update_block_device_mapping")
1484 def test_prepare_persistent_root_volumes_create_with_keep(
1485 self
, mock_update_block_device_mapping
1487 """Create persistent root volume, disk has keep parameter."""
1488 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1489 vm_av_zone
= ["nova"]
1490 base_disk_index
= ord("a")
1491 disk
= {"size": 10, "image_id": image_id
, "keep": True}
1492 block_device_mapping
= {}
1493 existing_vim_volumes
= []
1495 expected_boot_vol_id
= volume_id2
1496 expected_existing_vim_volumes
= []
1497 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1502 block_device_mapping
,
1503 existing_vim_volumes
,
1506 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1507 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1508 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1512 availability_zone
=["nova"],
1514 mock_update_block_device_mapping
.assert_called_once()
1515 _call_mock_update_block_device_mapping
= (
1516 mock_update_block_device_mapping
.call_args_list
1519 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1520 block_device_mapping
,
1523 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1525 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1527 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1530 @patch.object(vimconnector
, "update_block_device_mapping")
1531 def test_prepare_persistent_non_root_volumes_create(
1532 self
, mock_update_block_device_mapping
1534 """Create persistent non-root volume."""
1535 self
.vimconn
.cinder
= CopyingMock()
1536 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1537 vm_av_zone
= ["nova"]
1538 base_disk_index
= ord("a")
1540 block_device_mapping
= {}
1541 existing_vim_volumes
= []
1543 expected_existing_vim_volumes
= []
1544 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1548 block_device_mapping
,
1550 existing_vim_volumes
,
1554 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1555 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1556 size
=10, name
="basicvmvda", availability_zone
=["nova"]
1558 mock_update_block_device_mapping
.assert_called_once()
1559 _call_mock_update_block_device_mapping
= (
1560 mock_update_block_device_mapping
.call_args_list
1563 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1564 block_device_mapping
,
1567 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1569 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1571 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1574 @patch.object(vimconnector
, "update_block_device_mapping")
1575 def test_prepare_persistent_non_root_volumes_create_with_keep(
1576 self
, mock_update_block_device_mapping
1578 """Create persistent non-root volume."""
1579 self
.vimconn
.cinder
= CopyingMock()
1580 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1581 vm_av_zone
= ["nova"]
1582 base_disk_index
= ord("a")
1583 disk
= {"size": 10, "keep": True}
1584 block_device_mapping
= {}
1585 existing_vim_volumes
= []
1587 expected_existing_vim_volumes
= []
1588 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1592 block_device_mapping
,
1594 existing_vim_volumes
,
1598 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1599 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1600 size
=10, name
="basicvmvda", availability_zone
=["nova"]
1602 mock_update_block_device_mapping
.assert_called_once()
1603 _call_mock_update_block_device_mapping
= (
1604 mock_update_block_device_mapping
.call_args_list
1607 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1608 block_device_mapping
,
1611 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1613 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1615 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1618 @patch.object(vimconnector
, "update_block_device_mapping")
1619 def test_new_shared_volumes(self
, mock_update_block_device_mapping
):
1620 """Create shared volume."""
1621 self
.vimconn
.cinder
= CopyingMock()
1622 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id4
1623 shared_volume_data
= {"size": 10, "name": "shared-volume"}
1624 self
.vimconn
.cinder
.volumes
.create
.side_effect
= [
1625 Volume("avaible", "multiattach", "shared-volume", volume_id4
)
1627 result
= self
.vimconn
.new_shared_volumes(shared_volume_data
)
1628 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1629 size
=10, name
="shared-volume", volume_type
="multiattach"
1631 self
.assertEqual(result
[0], "shared-volume")
1632 self
.assertEqual(result
[1], volume_id4
)
1634 @patch.object(vimconnector
, "update_block_device_mapping")
1635 def test_prepare_persistent_root_volumes_create_raise_exception(
1636 self
, mock_update_block_device_mapping
1638 """Create persistent root volume raise exception."""
1639 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
1640 vm_av_zone
= ["nova"]
1641 base_disk_index
= ord("a")
1642 disk
= {"size": 10, "image_id": image_id
}
1643 block_device_mapping
= {}
1644 existing_vim_volumes
= []
1647 with self
.assertRaises(Exception):
1648 result
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1653 block_device_mapping
,
1654 existing_vim_volumes
,
1658 self
.assertEqual(result
, None)
1660 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1664 availability_zone
=["nova"],
1666 self
.assertEqual(existing_vim_volumes
, [])
1667 self
.assertEqual(block_device_mapping
, {})
1668 self
.assertEqual(created_items
, {})
1669 mock_update_block_device_mapping
.assert_not_called()
1671 @patch.object(vimconnector
, "update_block_device_mapping")
1672 def test_prepare_persistent_non_root_volumes_create_raise_exception(
1673 self
, mock_update_block_device_mapping
1675 """Create persistent non-root volume raise exception."""
1676 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
1677 vm_av_zone
= ["nova"]
1678 base_disk_index
= ord("b")
1680 block_device_mapping
= {}
1681 existing_vim_volumes
= []
1684 with self
.assertRaises(Exception):
1685 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1689 block_device_mapping
,
1691 existing_vim_volumes
,
1695 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1696 size
=10, name
="basicvmvdb", availability_zone
=["nova"]
1698 self
.assertEqual(existing_vim_volumes
, [])
1699 self
.assertEqual(block_device_mapping
, {})
1700 self
.assertEqual(created_items
, {})
1701 mock_update_block_device_mapping
.assert_not_called()
1703 @patch("time.sleep")
1704 def test_wait_for_created_volumes_availability_volume_status_available(
1707 """Created volume status is available."""
1709 created_items
= {f
"volume:{volume_id2}": True}
1710 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1712 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1713 elapsed_time
, created_items
1715 self
.assertEqual(result
, elapsed_time
)
1716 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1717 mock_sleep
.assert_not_called()
1719 @patch("time.sleep")
1720 def test_wait_for_existing_volumes_availability_volume_status_available(
1723 """Existing volume status is available."""
1725 existing_vim_volumes
= [{"id": volume_id2
}]
1726 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1728 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1729 elapsed_time
, existing_vim_volumes
1731 self
.assertEqual(result
, elapsed_time
)
1732 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1733 mock_sleep
.assert_not_called()
1735 @patch("time.sleep")
1736 def test_wait_for_created_volumes_availability_status_processing_multiple_volumes(
1739 """Created volume status is processing."""
1742 f
"volume:{volume_id2}": True,
1743 f
"volume:{volume_id3}": True,
1745 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1746 Volume("processing"),
1747 Volume("available"),
1748 Volume("available"),
1751 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1752 elapsed_time
, created_items
1754 self
.assertEqual(result
, 10)
1755 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
1756 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
1757 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
1758 self
.assertEqual(_call_mock_get_volumes
[2][0], (volume_id3
,))
1759 mock_sleep
.assert_called_with(5)
1760 self
.assertEqual(1, mock_sleep
.call_count
)
1762 @patch("time.sleep")
1763 def test_wait_for_existing_volumes_availability_status_processing_multiple_volumes(
1766 """Existing volume status is processing."""
1768 existing_vim_volumes
= [
1770 {"id": "44e0e83-b9uu-4akk-t234-p9cc4811bd4a"},
1772 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1773 Volume("processing"),
1774 Volume("available", "multiattach"),
1775 Volume("available"),
1778 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1779 elapsed_time
, existing_vim_volumes
1781 self
.assertEqual(result
, 10)
1782 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
1783 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
1784 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
1786 _call_mock_get_volumes
[2][0], ("44e0e83-b9uu-4akk-t234-p9cc4811bd4a",)
1788 mock_sleep
.assert_called_with(5)
1789 self
.assertEqual(1, mock_sleep
.call_count
)
1791 @patch("time.sleep")
1792 def test_wait_for_created_volumes_availability_volume_status_processing_timeout(
1795 """Created volume status is processing, elapsed time greater than timeout (1800)."""
1797 created_items
= {f
"volume:{volume_id2}": True}
1798 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1799 Volume("processing"),
1800 Volume("processing"),
1802 with
patch("time.sleep", mock_sleep
):
1803 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1804 elapsed_time
, created_items
1806 self
.assertEqual(result
, 1805)
1807 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1808 mock_sleep
.assert_not_called()
1810 @patch("time.sleep")
1811 def test_wait_for_existing_volumes_availability_volume_status_processing_timeout(
1814 """Exsiting volume status is processing, elapsed time greater than timeout (1800)."""
1816 existing_vim_volumes
= [{"id": volume_id2
}]
1817 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1818 Volume("processing"),
1819 Volume("processing"),
1822 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1823 elapsed_time
, existing_vim_volumes
1825 self
.assertEqual(result
, 1805)
1826 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1827 mock_sleep
.assert_not_called()
1829 @patch("time.sleep")
1830 def test_wait_for_created_volumes_availability_cinder_raise_exception(
1833 """Cinder get volumes raises exception for created volumes."""
1835 created_items
= {f
"volume:{volume_id2}": True}
1836 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
1837 with self
.assertRaises(Exception):
1838 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1839 elapsed_time
, created_items
1841 self
.assertEqual(result
, 1000)
1842 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1843 mock_sleep
.assert_not_called()
1845 @patch("time.sleep")
1846 def test_wait_for_existing_volumes_availability_cinder_raise_exception(
1849 """Cinder get volumes raises exception for existing volumes."""
1851 existing_vim_volumes
= [{"id": volume_id2
}]
1852 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
1853 with self
.assertRaises(Exception):
1854 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1855 elapsed_time
, existing_vim_volumes
1857 self
.assertEqual(result
, 1000)
1858 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1859 mock_sleep
.assert_not_called()
1861 @patch("time.sleep")
1862 def test_wait_for_created_volumes_availability_no_volume_in_created_items(
1865 """Created_items dict does not have volume-id."""
1869 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
1871 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1872 elapsed_time
, created_items
1874 self
.assertEqual(result
, 10)
1875 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1876 mock_sleep
.assert_not_called()
1878 @patch("time.sleep")
1879 def test_wait_for_existing_volumes_availability_no_volume_in_existing_vim_volumes(
1882 """Existing_vim_volumes list does not have volume."""
1884 existing_vim_volumes
= []
1886 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
1888 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1889 elapsed_time
, existing_vim_volumes
1891 self
.assertEqual(result
, 10)
1892 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1893 mock_sleep
.assert_not_called()
1895 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
1896 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
1897 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
1898 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
1899 def test_prepare_disk_for_vm_instance(
1901 mock_existing_vol_availability
,
1902 mock_created_vol_availability
,
1903 mock_non_root_volumes
,
1906 """Prepare disks for VM instance successfully."""
1907 existing_vim_volumes
= []
1909 block_device_mapping
= {}
1910 vm_av_zone
= ["nova"]
1912 mock_root_volumes
.return_value
= root_vol_id
1913 mock_created_vol_availability
.return_value
= 10
1914 mock_existing_vol_availability
.return_value
= 15
1915 self
.vimconn
.cinder
= CopyingMock()
1916 self
.vimconn
._prepare
_disk
_for
_vminstance
(
1918 existing_vim_volumes
,
1921 block_device_mapping
,
1924 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_called_once_with(
1927 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
1928 mock_existing_vol_availability
.assert_called_once_with(10, existing_vim_volumes
)
1929 self
.assertEqual(mock_root_volumes
.call_count
, 1)
1930 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
1931 mock_root_volumes
.assert_called_once_with(
1933 vm_av_zone
=["nova"],
1934 disk
={"size": 10, "image_id": image_id
},
1936 block_device_mapping
={},
1937 existing_vim_volumes
=[],
1940 mock_non_root_volumes
.assert_called_once_with(
1943 vm_av_zone
=["nova"],
1945 block_device_mapping
={},
1946 existing_vim_volumes
=[],
1950 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
1951 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
1952 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
1953 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
1954 def test_prepare_disk_for_vm_instance_timeout_exceeded(
1956 mock_existing_vol_availability
,
1957 mock_created_vol_availability
,
1958 mock_non_root_volumes
,
1961 """Timeout exceeded while waiting for disks."""
1962 existing_vim_volumes
= []
1964 vm_av_zone
= ["nova"]
1965 block_device_mapping
= {}
1967 mock_root_volumes
.return_value
= root_vol_id
1968 mock_created_vol_availability
.return_value
= 1700
1969 mock_existing_vol_availability
.return_value
= 1900
1971 with self
.assertRaises(VimConnException
) as err
:
1972 self
.vimconn
._prepare
_disk
_for
_vminstance
(
1974 existing_vim_volumes
,
1977 block_device_mapping
,
1981 str(err
.exception
), "Timeout creating volumes for instance basicvm"
1983 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
1984 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
1985 mock_existing_vol_availability
.assert_called_once_with(
1986 1700, existing_vim_volumes
1988 self
.assertEqual(mock_root_volumes
.call_count
, 1)
1989 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
1990 mock_root_volumes
.assert_called_once_with(
1992 vm_av_zone
=["nova"],
1993 disk
={"size": 10, "image_id": image_id
},
1995 block_device_mapping
={},
1996 existing_vim_volumes
=[],
1999 mock_non_root_volumes
.assert_called_once_with(
2002 vm_av_zone
=["nova"],
2004 block_device_mapping
={},
2005 existing_vim_volumes
=[],
2009 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2010 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2011 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2012 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2013 def test_prepare_disk_for_vm_instance_empty_disk_list(
2015 mock_existing_vol_availability
,
2016 mock_created_vol_availability
,
2017 mock_non_root_volumes
,
2020 """Disk list is empty."""
2021 existing_vim_volumes
= []
2023 block_device_mapping
= {}
2024 vm_av_zone
= ["nova"]
2025 mock_created_vol_availability
.return_value
= 2
2026 mock_existing_vol_availability
.return_value
= 3
2028 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2030 existing_vim_volumes
,
2033 block_device_mapping
,
2036 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2037 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2038 mock_existing_vol_availability
.assert_called_once_with(2, existing_vim_volumes
)
2039 mock_root_volumes
.assert_not_called()
2040 mock_non_root_volumes
.assert_not_called()
2042 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2043 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2044 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2045 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2046 def test_prepare_disk_for_vm_instance_persistent_root_volume_error(
2048 mock_existing_vol_availability
,
2049 mock_created_vol_availability
,
2050 mock_non_root_volumes
,
2053 """Persistent root volumes preparation raises error."""
2054 existing_vim_volumes
= []
2056 vm_av_zone
= ["nova"]
2057 block_device_mapping
= {}
2059 mock_root_volumes
.side_effect
= Exception()
2060 mock_created_vol_availability
.return_value
= 10
2061 mock_existing_vol_availability
.return_value
= 15
2063 with self
.assertRaises(Exception):
2064 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2066 existing_vim_volumes
,
2069 block_device_mapping
,
2072 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2073 mock_created_vol_availability
.assert_not_called()
2074 mock_existing_vol_availability
.assert_not_called()
2075 mock_root_volumes
.assert_called_once_with(
2077 vm_av_zone
=["nova"],
2078 disk
={"size": 10, "image_id": image_id
},
2080 block_device_mapping
={},
2081 existing_vim_volumes
=[],
2084 mock_non_root_volumes
.assert_not_called()
2086 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2087 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2088 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2089 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2090 def test_prepare_disk_for_vm_instance_non_root_volume_error(
2092 mock_existing_vol_availability
,
2093 mock_created_vol_availability
,
2094 mock_non_root_volumes
,
2097 """Non-root volumes preparation raises error."""
2098 existing_vim_volumes
= []
2100 vm_av_zone
= ["nova"]
2101 block_device_mapping
= {}
2103 mock_root_volumes
.return_value
= root_vol_id
2104 mock_non_root_volumes
.side_effect
= Exception
2106 with self
.assertRaises(Exception):
2107 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2109 existing_vim_volumes
,
2112 block_device_mapping
,
2115 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2116 mock_created_vol_availability
.assert_not_called()
2117 mock_existing_vol_availability
.assert_not_called()
2118 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2119 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2120 mock_root_volumes
.assert_called_once_with(
2122 vm_av_zone
=["nova"],
2123 disk
={"size": 10, "image_id": image_id
},
2125 block_device_mapping
={},
2126 existing_vim_volumes
=[],
2129 mock_non_root_volumes
.assert_called_once_with(
2132 vm_av_zone
=["nova"],
2134 block_device_mapping
={},
2135 existing_vim_volumes
=[],
2139 def test_find_external_network_for_floating_ip_no_external_network(self
):
2140 """External network could not be found."""
2141 self
.vimconn
.neutron
.list_networks
.return_value
= {
2143 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": False}
2146 with self
.assertRaises(VimConnException
) as err
:
2147 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2150 "Cannot create floating_ip automatically since no external network is present",
2153 def test_find_external_network_for_floating_one_external_network(self
):
2154 """One external network has been found."""
2155 self
.vimconn
.neutron
.list_networks
.return_value
= {
2157 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True}
2160 expected_result
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
2161 result
= self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2162 self
.assertEqual(result
, expected_result
)
2164 def test_find_external_network_for_floating_neutron_raises_exception(self
):
2165 """Neutron list networks raises exception."""
2166 self
.vimconn
.neutron
.list_networks
.side_effect
= Exception
2167 with self
.assertRaises(Exception):
2168 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2170 def test_find_external_network_for_floating_several_external_network(self
):
2171 """Several exernal networks has been found."""
2172 self
.vimconn
.neutron
.list_networks
.return_value
= {
2174 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True},
2175 {"id": "608b73-y9cc-5a6a-a270-12cc4811bd4a", "router:external": True},
2178 with self
.assertRaises(VimConnException
) as err
:
2179 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2182 "Cannot create floating_ip automatically since multiple external networks are present",
2185 def test_neutron_create_float_ip(self
):
2186 """Floating ip creation is successful."""
2187 param
= {"net_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a"}
2189 self
.vimconn
.neutron
.create_floatingip
.return_value
= {
2190 "floatingip": {"id": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2192 expected_created_items
= {
2193 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True
2195 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2196 self
.assertEqual(created_items
, expected_created_items
)
2198 def test_neutron_create_float_ip_exception_occurred(self
):
2199 """Floating ip could not be created."""
2202 "floating_network_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a",
2203 "tenant_id": "308b73-19cc-8a6a-a270-02cc4811bd9a",
2207 self
.vimconn
.neutron
= CopyingMock()
2208 self
.vimconn
.neutron
.create_floatingip
.side_effect
= Exception(
2209 "Neutron floating ip create exception occurred."
2211 with self
.assertRaises(VimConnException
) as err
:
2212 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2213 self
.assertEqual(created_items
, {})
2216 "Exception: Cannot create new floating_ip Neutron floating ip create exception occurred.",
2219 @patch.object(vimconnector
, "_neutron_create_float_ip")
2220 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2221 def test_create_floating_ip_pool_id_available(
2222 self
, mock_find_ext_network
, mock_create_float_ip
2224 """Floating ip creation, ip pool is available."""
2225 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2229 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2230 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2233 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2234 mock_find_ext_network
.assert_not_called()
2235 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2237 @patch.object(vimconnector
, "_neutron_create_float_ip")
2238 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2239 def test_create_floating_ip_finding_pool_id(
2240 self
, mock_find_ext_network
, mock_create_float_ip
2242 """Floating ip creation, pool id need to be found."""
2243 floating_network
= {"floating_ip": True}
2245 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2248 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2249 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2252 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2253 mock_find_ext_network
.assert_called_once()
2254 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2256 @patch.object(vimconnector
, "_neutron_create_float_ip")
2257 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2258 def test_create_floating_ip_neutron_create_floating_ip_exception(
2259 self
, mock_find_ext_network
, mock_create_float_ip
2261 """Neutron creat floating ip raises error."""
2262 floating_network
= {"floating_ip": True}
2264 mock_create_float_ip
.side_effect
= VimConnException(
2265 "Can not create floating ip."
2267 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2270 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2271 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2275 with self
.assertRaises(VimConnException
) as err
:
2276 self
.vimconn
._create
_floating
_ip
(
2277 floating_network
, self
.server
, created_items
2279 self
.assertEqual(str(err
.exception
), "Can not create floating ip.")
2280 mock_find_ext_network
.assert_called_once()
2281 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2283 @patch.object(vimconnector
, "_neutron_create_float_ip")
2284 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2285 def test_create_floating_ip_can_not_find_pool_id(
2286 self
, mock_find_ext_network
, mock_create_float_ip
2288 """Floating ip creation, pool id could not be found."""
2289 floating_network
= {"floating_ip": True}
2291 mock_find_ext_network
.side_effect
= VimConnException(
2292 "Cannot create floating_ip automatically since no external network is present"
2294 with self
.assertRaises(VimConnException
) as err
:
2295 self
.vimconn
._create
_floating
_ip
(
2296 floating_network
, self
.server
, created_items
2300 "Cannot create floating_ip automatically since no external network is present",
2302 mock_find_ext_network
.assert_called_once()
2303 mock_create_float_ip
.assert_not_called()
2305 def test_find_floating_ip_get_free_floating_ip(self
):
2306 """Get free floating ips successfully."""
2309 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2310 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2311 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2314 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2315 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2317 result
= self
.vimconn
._find
_floating
_ip
(
2318 self
.server
, floating_ips
, floating_network
2320 self
.assertEqual(result
, expected_result
)
2322 def test_find_floating_ip_different_floating_network_id(self
):
2323 """Floating network id is different with floating_ip of floating network."""
2326 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2327 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2330 floating_network
= {"floating_ip": "508b73-t9cc-1a6a-a270-12cc4811bd4a"}
2332 result
= self
.vimconn
._find
_floating
_ip
(
2333 self
.server
, floating_ips
, floating_network
2335 self
.assertEqual(result
, None)
2337 def test_find_floating_ip_different_fip_tenant(self
):
2338 """Items in floating_ips has port_id, tenant_is is not same with server tenant id."""
2341 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2342 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2343 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2344 "tenant_id": self
.server
.id,
2347 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2348 mock_create_floating_ip
= CopyingMock()
2349 with patch
.object(vimconnector
, "_create_floating_ip", mock_create_floating_ip
):
2350 result
= self
.vimconn
._find
_floating
_ip
(
2351 self
.server
, floating_ips
, floating_network
2353 self
.assertEqual(result
, None)
2355 @patch("time.sleep")
2356 def test_assign_floating_ip(self
, mock_sleep
):
2357 """Assign floating ip successfully."""
2358 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2359 floating_network
= {"vim_id": floating_network_vim_id
}
2361 "port_id": floating_network_vim_id
,
2362 "floating_network_id": "p08b73-e9cc-5a6a-t270-82cc4811bd4a",
2363 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2364 "tenant_id": "k08b73-e9cc-5a6a-t270-82cc4811bd4a",
2366 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
2367 self
.vimconn
.neutron
.show_floatingip
.return_value
= fip
2368 expected_result
= fip
2370 result
= self
.vimconn
._assign
_floating
_ip
(free_floating_ip
, floating_network
)
2371 self
.assertEqual(result
, expected_result
)
2372 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2374 {"floatingip": {"port_id": floating_network_vim_id
}},
2376 mock_sleep
.assert_called_once_with(5)
2377 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
2379 @patch("time.sleep")
2380 def test_assign_floating_ip_update_floating_ip_exception(self
, mock_sleep
):
2381 """Neutron update floating ip raises exception."""
2382 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2383 floating_network
= {"vim_id": floating_network_vim_id
}
2384 self
.vimconn
.neutron
= CopyingMock()
2385 self
.vimconn
.neutron
.update_floatingip
.side_effect
= Exception(
2386 "Floating ip is not updated."
2389 with self
.assertRaises(Exception) as err
:
2390 result
= self
.vimconn
._assign
_floating
_ip
(
2391 free_floating_ip
, floating_network
2393 self
.assertEqual(result
, None)
2394 self
.assertEqual(str(err
.exception
), "Floating ip is not updated.")
2396 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2398 {"floatingip": {"port_id": floating_network_vim_id
}},
2400 mock_sleep
.assert_not_called()
2401 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2403 @patch("time.sleep")
2404 def test_assign_floating_ip_show_floating_ip_exception(self
, mock_sleep
):
2405 """Neutron show floating ip raises exception."""
2406 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2407 floating_network
= {"vim_id": floating_network_vim_id
}
2408 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
2409 self
.vimconn
.neutron
.show_floatingip
.side_effect
= Exception(
2410 "Floating ip could not be shown."
2413 with self
.assertRaises(Exception) as err
:
2414 result
= self
.vimconn
._assign
_floating
_ip
(
2415 free_floating_ip
, floating_network
2417 self
.assertEqual(result
, None)
2418 self
.assertEqual(str(err
.exception
), "Floating ip could not be shown.")
2419 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2421 {"floatingip": {"port_id": floating_network_vim_id
}},
2423 mock_sleep
.assert_called_once_with(5)
2424 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
2426 @patch("random.shuffle")
2427 @patch.object(vimconnector
, "_find_floating_ip")
2428 def test_get_free_floating_ip(self
, mock_find_floating_ip
, mock_shuffle
):
2429 """Get free floating ip successfully."""
2430 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2433 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2434 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2435 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2436 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2439 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
2440 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2441 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
2442 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2445 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
2446 "floatingips": floating_ips
2448 mock_find_floating_ip
.return_value
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2449 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2451 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2452 self
.assertEqual(result
, expected_result
)
2453 mock_shuffle
.assert_called_once_with(floating_ips
)
2454 mock_find_floating_ip
.assert_called_once_with(
2455 self
.server
, floating_ips
, floating_network
2458 @patch("random.shuffle")
2459 @patch.object(vimconnector
, "_find_floating_ip")
2460 def test_get_free_floating_ip_list_floating_ip_exception(
2461 self
, mock_find_floating_ip
, mock_shuffle
2463 """Neutron list floating IPs raises exception."""
2464 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2465 self
.vimconn
.neutron
= CopyingMock()
2466 self
.vimconn
.neutron
.list_floatingips
.side_effect
= Exception(
2467 "Floating ips could not be listed."
2469 with self
.assertRaises(Exception) as err
:
2470 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2471 self
.assertEqual(result
, None)
2472 self
.assertEqual(str(err
.exception
), "Floating ips could not be listed.")
2473 mock_shuffle
.assert_not_called()
2474 mock_find_floating_ip
.assert_not_called()
2476 @patch("random.shuffle")
2477 @patch.object(vimconnector
, "_find_floating_ip")
2478 def test_get_free_floating_ip_find_floating_ip_exception(
2479 self
, mock_find_floating_ip
, mock_shuffle
2481 """_find_floating_ip method raises exception."""
2482 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2485 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2486 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2487 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2488 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2491 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
2492 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2493 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
2494 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2497 self
.vimconn
.neutron
= CopyingMock()
2498 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
2499 "floatingips": floating_ips
2501 mock_find_floating_ip
.side_effect
= Exception(
2502 "Free floating ip could not be found."
2505 with self
.assertRaises(Exception) as err
:
2506 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2507 self
.assertEqual(result
, None)
2508 self
.assertEqual(str(err
.exception
), "Free floating ip could not be found.")
2509 mock_shuffle
.assert_called_once_with(floating_ips
)
2510 mock_find_floating_ip
.assert_called_once_with(
2511 self
.server
, floating_ips
, floating_network
2514 @patch.object(vimconnector
, "_create_floating_ip")
2515 @patch.object(vimconnector
, "_get_free_floating_ip")
2516 @patch.object(vimconnector
, "_assign_floating_ip")
2517 def test_prepare_external_network_for_vm_instance(
2519 mock_assign_floating_ip
,
2520 mock_get_free_floating_ip
,
2521 mock_create_floating_ip
,
2523 """Prepare external network successfully."""
2524 external_network
= [
2526 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2527 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2531 vm_start_time
= time_return_value
2532 mock_get_free_floating_ip
.side_effect
= ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
2533 mock_assign_floating_ip
.return_value
= {
2534 "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
2536 self
.vimconn
.neutron
= CopyingMock()
2537 self
.vimconn
.nova
= CopyingMock()
2538 self
.vimconn
.neutron
.show_floatingip
.return_value
= {
2539 "floatingip": {"port_id": ""}
2542 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2543 external_network
, self
.server
, created_items
, vm_start_time
2546 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2547 mock_get_free_floating_ip
.assert_called_once_with(
2550 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2551 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2554 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(
2555 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
2557 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2558 mock_create_floating_ip
.assert_not_called()
2559 mock_assign_floating_ip
.assert_called_once_with(
2560 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2562 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2563 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2568 @patch("time.sleep")
2569 @patch.object(vimconnector
, "_create_floating_ip")
2570 @patch.object(vimconnector
, "_get_free_floating_ip")
2571 @patch.object(vimconnector
, "_assign_floating_ip")
2572 def test_prepare_external_network_for_vm_instance_no_free_floating_ip(
2574 mock_assign_floating_ip
,
2575 mock_get_free_floating_ip
,
2576 mock_create_floating_ip
,
2580 """There is not any free floating ip."""
2581 floating_network
= {
2582 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2583 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2585 external_network
= [floating_network
]
2588 vm_start_time
= time_return_value
2589 mock_get_free_floating_ip
.return_value
= None
2590 mock_assign_floating_ip
.return_value
= {}
2591 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2592 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2594 with self
.assertRaises(KeyError):
2595 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2596 external_network
, self
.server
, created_items
, vm_start_time
2599 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2600 mock_get_free_floating_ip
.assert_called_with(
2603 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2604 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2607 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(None)
2608 mock_sleep
.assert_not_called()
2609 mock_time
.assert_not_called()
2610 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
2611 mock_create_floating_ip
.assert_called_with(
2612 floating_network
, self
.server
, created_items
2614 self
.assertEqual(mock_create_floating_ip
.call_count
, 4)
2615 mock_assign_floating_ip
.assert_not_called()
2616 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2619 @patch("time.sleep")
2620 @patch.object(vimconnector
, "_create_floating_ip")
2621 @patch.object(vimconnector
, "_get_free_floating_ip")
2622 @patch.object(vimconnector
, "_assign_floating_ip")
2623 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
2625 mock_assign_floating_ip
,
2626 mock_get_free_floating_ip
,
2627 mock_create_floating_ip
,
2631 """There is not any free floating ip, create_floating ip method raise exception
2632 exit_on_floating_ip_error set to False."""
2633 floating_network
= {
2634 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2635 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2636 "exit_on_floating_ip_error": False,
2638 external_network
= [floating_network
]
2641 vm_start_time
= time_return_value
2642 mock_get_free_floating_ip
.return_value
= None
2643 mock_assign_floating_ip
.return_value
= {}
2644 mock_create_floating_ip
.side_effect
= VimConnException(
2645 "Can not create floating ip."
2647 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2648 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2650 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2651 external_network
, self
.server
, created_items
, vm_start_time
2653 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2654 mock_get_free_floating_ip
.assert_called_with(
2657 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2658 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2659 "exit_on_floating_ip_error": False,
2662 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2663 mock_sleep
.assert_not_called()
2664 mock_time
.assert_not_called()
2665 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2666 mock_create_floating_ip
.assert_called_with(
2667 floating_network
, self
.server
, created_items
2669 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
2670 mock_assign_floating_ip
.assert_not_called()
2673 @patch("time.sleep")
2674 @patch.object(vimconnector
, "_create_floating_ip")
2675 @patch.object(vimconnector
, "_get_free_floating_ip")
2676 @patch.object(vimconnector
, "_assign_floating_ip")
2677 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
2679 mock_assign_floating_ip
,
2680 mock_get_free_floating_ip
,
2681 mock_create_floating_ip
,
2685 """There is not any free floating ip, create_floating ip method raise exception
2686 exit_on_floating_ip_error set to False."""
2687 floating_network
= {
2688 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2689 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2690 "exit_on_floating_ip_error": True,
2692 external_network
= [floating_network
]
2695 vm_start_time
= time_return_value
2696 mock_get_free_floating_ip
.return_value
= None
2697 mock_assign_floating_ip
.return_value
= {}
2698 mock_create_floating_ip
.side_effect
= VimConnException(
2699 "Can not create floating ip."
2701 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2702 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2703 with self
.assertRaises(VimConnException
):
2704 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2705 external_network
, self
.server
, created_items
, vm_start_time
2707 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2708 mock_get_free_floating_ip
.assert_called_with(
2711 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2712 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2713 "exit_on_floating_ip_error": True,
2716 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2717 mock_sleep
.assert_not_called()
2718 mock_time
.assert_not_called()
2719 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2720 mock_create_floating_ip
.assert_called_with(
2721 floating_network
, self
.server
, created_items
2723 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
2724 mock_assign_floating_ip
.assert_not_called()
2726 @patch.object(vimconnector
, "_create_floating_ip")
2727 @patch.object(vimconnector
, "_get_free_floating_ip")
2728 @patch.object(vimconnector
, "_assign_floating_ip")
2729 def test_prepare_external_network_for_vm_instance_fip_has_port_id(
2731 mock_assign_floating_ip
,
2732 mock_get_free_floating_ip
,
2733 mock_create_floating_ip
,
2735 """Neutron show floating ip return the fip with port_id and floating network vim_id
2736 is different from port_id."""
2737 floating_network
= {
2738 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2739 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2741 external_network
= [floating_network
]
2744 mock_get_free_floating_ip
.side_effect
= [
2745 "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
2746 "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
2747 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2749 mock_assign_floating_ip
.side_effect
= [
2750 {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2751 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2753 self
.vimconn
.neutron
= CopyingMock()
2754 self
.vimconn
.nova
= CopyingMock()
2755 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2756 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2757 {"floatingip": {"port_id": ""}},
2758 {"floatingip": {"port_id": ""}},
2760 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2761 external_network
, self
.server
, created_items
, vm_start_time
2763 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
2764 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2766 _call_mock_get_free_floating_ip
[0][0],
2773 _call_mock_get_free_floating_ip
[1][0],
2780 _call_mock_get_free_floating_ip
[2][0],
2786 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
2787 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2788 mock_create_floating_ip
.assert_not_called()
2789 self
.assertEqual(mock_assign_floating_ip
.call_count
, 2)
2790 _call_mock_assign_floating_ip
= mock_assign_floating_ip
.call_args_list
2792 _call_mock_assign_floating_ip
[0][0],
2793 ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
2796 _call_mock_assign_floating_ip
[1][0],
2797 ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
2801 @patch("time.sleep")
2802 @patch.object(vimconnector
, "_create_floating_ip")
2803 @patch.object(vimconnector
, "_get_free_floating_ip")
2804 @patch.object(vimconnector
, "_assign_floating_ip")
2805 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
2807 mock_assign_floating_ip
,
2808 mock_get_free_floating_ip
,
2809 mock_create_floating_ip
,
2813 """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
2814 VM status is in error."""
2815 floating_network
= {
2816 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2817 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2818 "exit_on_floating_ip_error": True,
2820 external_network
= [floating_network
]
2822 vm_start_time
= time_return_value
2824 mock_time
.side_effect
= [156570150, 156570800, 156571200]
2826 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2827 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2828 Exception("Floating ip could not be shown.")
2830 with self
.assertRaises(Exception) as err
:
2831 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2832 external_network
, self
.server
, created_items
, vm_start_time
2836 "Cannot create floating_ip: Exception Floating ip could not be shown.",
2839 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2840 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2842 _call_mock_get_free_floating_ip
[0][0],
2849 _call_mock_get_free_floating_ip
[1][0],
2856 _call_mock_get_free_floating_ip
[2][0],
2863 _call_mock_get_free_floating_ip
[3][0],
2870 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
2871 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2872 mock_create_floating_ip
.assert_not_called()
2873 mock_assign_floating_ip
.assert_not_called()
2874 mock_time
.assert_not_called()
2875 mock_sleep
.assert_not_called()
2878 @patch("time.sleep")
2879 @patch.object(vimconnector
, "_create_floating_ip")
2880 @patch.object(vimconnector
, "_get_free_floating_ip")
2881 @patch.object(vimconnector
, "_assign_floating_ip")
2882 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
2884 mock_assign_floating_ip
,
2885 mock_get_free_floating_ip
,
2886 mock_create_floating_ip
,
2890 """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
2891 VM status is in active."""
2892 floating_network
= {
2893 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2894 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2895 "exit_on_floating_ip_error": False,
2897 external_network
= [floating_network
]
2899 vm_start_time
= time_return_value
2901 mock_time
.side_effect
= [156570150, 156570800, 156571200]
2903 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ACTIVE"
2904 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2905 Exception("Floating ip could not be shown.")
2908 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2909 external_network
, self
.server
, created_items
, vm_start_time
2911 # self.assertEqual(str(err.exception), "Cannot create floating_ip")
2913 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2914 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2916 _call_mock_get_free_floating_ip
[0][0],
2923 _call_mock_get_free_floating_ip
[1][0],
2930 _call_mock_get_free_floating_ip
[2][0],
2937 _call_mock_get_free_floating_ip
[3][0],
2944 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
2945 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2946 mock_create_floating_ip
.assert_not_called()
2947 mock_assign_floating_ip
.assert_not_called()
2948 mock_time
.assert_not_called()
2949 mock_sleep
.assert_not_called()
2952 @patch("time.sleep")
2953 @patch.object(vimconnector
, "_create_floating_ip")
2954 @patch.object(vimconnector
, "_get_free_floating_ip")
2955 @patch.object(vimconnector
, "_assign_floating_ip")
2956 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
2958 mock_assign_floating_ip
,
2959 mock_get_free_floating_ip
,
2960 mock_create_floating_ip
,
2964 """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
2965 VM status is not ACTIVE or ERROR, server timeout happened."""
2966 floating_network
= {
2967 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2968 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2969 "exit_on_floating_ip_error": True,
2971 external_network
= [floating_network
]
2973 vm_start_time
= time_return_value
2974 mock_get_free_floating_ip
.side_effect
= None
2975 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
2976 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "OTHER"
2977 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2978 Exception("Floating ip could not be shown.")
2981 with self
.assertRaises(VimConnException
) as err
:
2982 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2983 external_network
, self
.server
, created_items
, vm_start_time
2987 "Cannot create floating_ip: Exception Floating ip could not be shown.",
2990 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
2991 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2993 _call_mock_get_free_floating_ip
[0][0],
3000 _call_mock_get_free_floating_ip
[1][0],
3007 _call_mock_get_free_floating_ip
[2][0],
3014 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3015 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3016 mock_create_floating_ip
.assert_not_called()
3017 mock_assign_floating_ip
.assert_not_called()
3018 self
.assertEqual(mock_time
.call_count
, 3)
3019 self
.assertEqual(mock_sleep
.call_count
, 2)
3022 @patch("time.sleep")
3023 @patch.object(vimconnector
, "_create_floating_ip")
3024 @patch.object(vimconnector
, "_get_free_floating_ip")
3025 @patch.object(vimconnector
, "_assign_floating_ip")
3026 def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3028 mock_assign_floating_ip
,
3029 mock_get_free_floating_ip
,
3030 mock_create_floating_ip
,
3034 """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3035 VM status is in ERROR."""
3036 floating_network
= {
3037 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3038 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3039 "exit_on_floating_ip_error": True,
3041 external_network
= [floating_network
]
3043 vm_start_time
= time_return_value
3045 mock_get_free_floating_ip
.side_effect
= [
3046 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3049 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3051 mock_assign_floating_ip
.side_effect
= [
3052 Exception("Floating ip could not be assigned.")
3055 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3056 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3057 {"floatingip": {"port_id": ""}}
3060 with self
.assertRaises(VimConnException
) as err
:
3061 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3062 external_network
, self
.server
, created_items
, vm_start_time
3066 "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3069 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3070 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3072 _call_mock_get_free_floating_ip
[0][0],
3079 _call_mock_get_free_floating_ip
[1][0],
3086 _call_mock_get_free_floating_ip
[2][0],
3093 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3094 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(
3095 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3097 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3098 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3099 mock_time
.assert_not_called()
3100 mock_sleep
.assert_not_called()
3101 mock_create_floating_ip
.assert_not_called()
3104 @patch("time.sleep")
3105 @patch.object(vimconnector
, "_create_floating_ip")
3106 @patch.object(vimconnector
, "_get_free_floating_ip")
3107 @patch.object(vimconnector
, "_assign_floating_ip")
3108 def test_prepare_external_network_for_vm_instance_empty_external_network_list(
3110 mock_assign_floating_ip
,
3111 mock_get_free_floating_ip
,
3112 mock_create_floating_ip
,
3116 """External network list is empty."""
3117 external_network
= []
3119 vm_start_time
= time_return_value
3121 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3122 external_network
, self
.server
, created_items
, vm_start_time
3124 mock_create_floating_ip
.assert_not_called()
3125 mock_time
.assert_not_called()
3126 mock_sleep
.assert_not_called()
3127 mock_assign_floating_ip
.assert_not_called()
3128 mock_get_free_floating_ip
.assert_not_called()
3129 self
.vimconn
.neutron
.show
.show_floatingip
.assert_not_called()
3130 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3132 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3133 def test_update_port_security_for_vm_instance(self
, mock_wait_for_vm
):
3134 """no_secured_ports has port and the port has allow-address-pairs."""
3135 no_secured_ports
= [(port2_id
, "allow-address-pairs")]
3137 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3139 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3141 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3143 {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
3146 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3147 def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
3148 self
, mock_wait_for_vm
3150 """no_secured_ports has port and the port does not have allow-address-pairs."""
3151 no_secured_ports
= [(port2_id
, "something")]
3153 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3155 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3157 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3159 {"port": {"port_security_enabled": False, "security_groups": None}},
3162 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3163 def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
3164 self
, mock_wait_for_vm
3166 """__wait_for_vm raises timeout exception."""
3167 no_secured_ports
= [(port2_id
, "something")]
3169 mock_wait_for_vm
.side_effect
= VimConnException("Timeout waiting for instance.")
3171 with self
.assertRaises(VimConnException
) as err
:
3172 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3173 no_secured_ports
, self
.server
3175 self
.assertEqual(str(err
.exception
), "Timeout waiting for instance.")
3177 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3179 self
.vimconn
.neutron
.update_port
.assert_not_called()
3181 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3182 def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
3183 self
, mock_wait_for_vm
3185 """neutron_update_port method raises exception."""
3186 no_secured_ports
= [(port2_id
, "something")]
3188 self
.vimconn
.neutron
.update_port
.side_effect
= Exception(
3189 "Port security could not be updated."
3192 with self
.assertRaises(VimConnException
) as err
:
3193 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3194 no_secured_ports
, self
.server
3198 "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
3200 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3202 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3204 {"port": {"port_security_enabled": False, "security_groups": None}},
3207 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3208 def test_update_port_security_for_vm_instance_empty_port_list(
3209 self
, mock_wait_for_vm
3211 """no_secured_ports list does not have any ports."""
3212 no_secured_ports
= []
3214 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3216 mock_wait_for_vm
.assert_not_called()
3218 self
.vimconn
.neutron
.update_port
.assert_not_called()
3221 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3222 @patch.object(vimconnector
, "_reload_connection")
3223 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3224 @patch.object(vimconnector
, "_create_user_data")
3225 @patch.object(vimconnector
, "_get_vm_availability_zone")
3226 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3227 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3228 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3229 @patch.object(vimconnector
, "delete_vminstance")
3230 @patch.object(vimconnector
, "_format_exception")
3231 def test_new_vm_instance(
3233 mock_format_exception
,
3234 mock_delete_vm_instance
,
3235 mock_prepare_external_network
,
3236 mock_update_port_security
,
3237 mock_prepare_disk_for_vm_instance
,
3238 mock_get_vm_availability_zone
,
3239 mock_create_user_data
,
3240 mock_prepare_network_for_vm_instance
,
3241 mock_reload_connection
,
3242 mock_remove_keep_flag_from_persistent_volumes
,
3245 """New VM instance creation is successful."""
3247 mock_create_user_data
.return_value
= True, "userdata"
3249 mock_get_vm_availability_zone
.return_value
= "nova"
3251 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3253 mock_time
.return_value
= time_return_value
3255 expected_result
= self
.server
.id, {}
3257 result
= self
.vimconn
.new_vminstance(
3263 affinity_group_list
,
3267 availability_zone_index
,
3268 availability_zone_list
,
3270 self
.assertEqual(result
, expected_result
)
3272 mock_reload_connection
.assert_called_once()
3273 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3278 external_network
=[],
3279 no_secured_ports
=[],
3281 mock_create_user_data
.assert_called_once_with(cloud_config
)
3282 mock_get_vm_availability_zone
.assert_called_once_with(
3283 availability_zone_index
, availability_zone_list
3285 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3287 existing_vim_volumes
=[],
3290 block_device_mapping
={},
3291 disk_list
=disk_list2
,
3293 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3298 security_groups
="default",
3299 availability_zone
="nova",
3300 key_name
="my_keypair",
3301 userdata
="userdata",
3303 block_device_mapping
={},
3306 mock_time
.assert_called_once()
3307 mock_update_port_security
.assert_called_once_with([], self
.server
)
3308 mock_prepare_external_network
.assert_called_once_with(
3309 external_network
=[],
3312 vm_start_time
=time_return_value
,
3314 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
3315 mock_delete_vm_instance
.assert_not_called()
3316 mock_format_exception
.assert_not_called()
3319 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3320 @patch.object(vimconnector
, "_reload_connection")
3321 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3322 @patch.object(vimconnector
, "_create_user_data")
3323 @patch.object(vimconnector
, "_get_vm_availability_zone")
3324 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3325 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3326 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3327 @patch.object(vimconnector
, "delete_vminstance")
3328 @patch.object(vimconnector
, "_format_exception")
3329 def test_new_vm_instance_create_user_data_fails(
3331 mock_format_exception
,
3332 mock_delete_vm_instance
,
3333 mock_prepare_external_network
,
3334 mock_update_port_security
,
3335 mock_prepare_disk_for_vm_instance
,
3336 mock_get_vm_availability_zone
,
3337 mock_create_user_data
,
3338 mock_prepare_network_for_vm_instance
,
3339 mock_reload_connection
,
3340 mock_remove_keep_flag_from_persistent_volumes
,
3343 """New VM instance creation failed because of user data creation failure."""
3345 mock_create_user_data
.side_effect
= Exception(
3346 "User data could not be retrieved."
3349 mock_get_vm_availability_zone
.return_value
= "nova"
3351 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3353 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3355 mock_time
.return_value
= time_return_value
3357 self
.vimconn
.new_vminstance(
3363 affinity_group_list
,
3367 availability_zone_index
,
3368 availability_zone_list
,
3371 mock_reload_connection
.assert_called_once()
3372 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3377 external_network
=[],
3378 no_secured_ports
=[],
3380 mock_create_user_data
.assert_called_once_with(cloud_config
)
3381 mock_get_vm_availability_zone
.assert_not_called()
3382 mock_prepare_disk_for_vm_instance
.assert_not_called()
3383 self
.vimconn
.nova
.servers
.create
.assert_not_called()
3384 mock_time
.assert_not_called()
3385 mock_update_port_security
.assert_not_called()
3386 mock_prepare_external_network
.assert_not_called()
3387 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3388 mock_delete_vm_instance
.assert_called_once_with(None, {})
3389 mock_format_exception
.assert_called_once()
3390 arg
= mock_format_exception
.call_args
[0][0]
3391 self
.assertEqual(str(arg
), "User data could not be retrieved.")
3394 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3395 @patch.object(vimconnector
, "_reload_connection")
3396 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3397 @patch.object(vimconnector
, "_create_user_data")
3398 @patch.object(vimconnector
, "_get_vm_availability_zone")
3399 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3400 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3401 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3402 @patch.object(vimconnector
, "delete_vminstance")
3403 @patch.object(vimconnector
, "_format_exception")
3404 def test_new_vm_instance_external_network_exception(
3406 mock_format_exception
,
3407 mock_delete_vm_instance
,
3408 mock_prepare_external_network
,
3409 mock_update_port_security
,
3410 mock_prepare_disk_for_vm_instance
,
3411 mock_get_vm_availability_zone
,
3412 mock_create_user_data
,
3413 mock_prepare_network_for_vm_instance
,
3414 mock_reload_connection
,
3415 mock_remove_keep_flag_from_persistent_volumes
,
3418 """New VM instance creation, external network connection has failed as floating
3419 ip could not be created."""
3421 mock_create_user_data
.return_value
= True, "userdata"
3423 mock_get_vm_availability_zone
.return_value
= "nova"
3425 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3427 mock_time
.return_value
= time_return_value
3429 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3431 mock_prepare_external_network
.side_effect
= VimConnException(
3432 "Can not create floating ip."
3435 self
.vimconn
.new_vminstance(
3441 affinity_group_list
,
3445 availability_zone_index
,
3446 availability_zone_list
,
3449 mock_reload_connection
.assert_called_once()
3450 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3455 external_network
=[],
3456 no_secured_ports
=[],
3458 mock_create_user_data
.assert_called_once_with(cloud_config
)
3459 mock_get_vm_availability_zone
.assert_called_once_with(
3460 availability_zone_index
, availability_zone_list
3462 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3464 existing_vim_volumes
=[],
3467 block_device_mapping
={},
3468 disk_list
=disk_list2
,
3470 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3475 security_groups
="default",
3476 availability_zone
="nova",
3477 key_name
="my_keypair",
3478 userdata
="userdata",
3480 block_device_mapping
={},
3483 mock_time
.assert_called_once()
3484 mock_update_port_security
.assert_called_once_with([], self
.server
)
3485 mock_prepare_external_network
.assert_called_once_with(
3486 external_network
=[],
3489 vm_start_time
=time_return_value
,
3491 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3492 mock_delete_vm_instance
.assert_called_once_with(self
.server
.id, {})
3493 mock_format_exception
.assert_called_once()
3494 arg
= mock_format_exception
.call_args
[0][0]
3495 self
.assertEqual(str(arg
), "Can not create floating ip.")
3498 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3499 @patch.object(vimconnector
, "_reload_connection")
3500 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3501 @patch.object(vimconnector
, "_create_user_data")
3502 @patch.object(vimconnector
, "_get_vm_availability_zone")
3503 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3504 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3505 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3506 @patch.object(vimconnector
, "delete_vminstance")
3507 @patch.object(vimconnector
, "_format_exception")
3508 def test_new_vm_instance_with_affinity_group(
3510 mock_format_exception
,
3511 mock_delete_vm_instance
,
3512 mock_prepare_external_network
,
3513 mock_update_port_security
,
3514 mock_prepare_disk_for_vm_instance
,
3515 mock_get_vm_availability_zone
,
3516 mock_create_user_data
,
3517 mock_prepare_network_for_vm_instance
,
3518 mock_reload_connection
,
3519 mock_remove_keep_flag_from_persistent_volumes
,
3522 """New VM creation with affinity group."""
3523 affinity_group_list
= [
3524 {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
3526 mock_create_user_data
.return_value
= True, "userdata"
3527 mock_get_vm_availability_zone
.return_value
= "nova"
3528 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3529 mock_time
.return_value
= time_return_value
3530 expected_result
= self
.server
.id, {}
3532 result
= self
.vimconn
.new_vminstance(
3538 affinity_group_list
,
3542 availability_zone_index
,
3543 availability_zone_list
,
3545 self
.assertEqual(result
, expected_result
)
3547 mock_reload_connection
.assert_called_once()
3548 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3553 external_network
=[],
3554 no_secured_ports
=[],
3556 mock_create_user_data
.assert_called_once_with(cloud_config
)
3557 mock_get_vm_availability_zone
.assert_called_once_with(
3558 availability_zone_index
, availability_zone_list
3560 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3562 existing_vim_volumes
=[],
3565 block_device_mapping
={},
3566 disk_list
=disk_list2
,
3568 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3573 security_groups
="default",
3574 availability_zone
="nova",
3575 key_name
="my_keypair",
3576 userdata
="userdata",
3578 block_device_mapping
={},
3579 scheduler_hints
={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
3581 mock_time
.assert_called_once()
3582 mock_update_port_security
.assert_called_once_with([], self
.server
)
3583 mock_prepare_external_network
.assert_called_once_with(
3584 external_network
=[],
3587 vm_start_time
=time_return_value
,
3589 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
3590 mock_delete_vm_instance
.assert_not_called()
3591 mock_format_exception
.assert_not_called()
3594 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3595 @patch.object(vimconnector
, "_reload_connection")
3596 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3597 @patch.object(vimconnector
, "_create_user_data")
3598 @patch.object(vimconnector
, "_get_vm_availability_zone")
3599 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3600 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3601 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3602 @patch.object(vimconnector
, "delete_vminstance")
3603 @patch.object(vimconnector
, "_format_exception")
3604 def test_new_vm_instance_nova_server_create_failed(
3606 mock_format_exception
,
3607 mock_delete_vm_instance
,
3608 mock_prepare_external_network
,
3609 mock_update_port_security
,
3610 mock_prepare_disk_for_vm_instance
,
3611 mock_get_vm_availability_zone
,
3612 mock_create_user_data
,
3613 mock_prepare_network_for_vm_instance
,
3614 mock_reload_connection
,
3615 mock_remove_keep_flag_from_persistent_volumes
,
3618 """New VM(server) creation failed."""
3620 mock_create_user_data
.return_value
= True, "userdata"
3622 mock_get_vm_availability_zone
.return_value
= "nova"
3624 self
.vimconn
.nova
.servers
.create
.side_effect
= Exception(
3625 "Server could not be created."
3628 mock_time
.return_value
= time_return_value
3630 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3632 self
.vimconn
.new_vminstance(
3638 affinity_group_list
,
3642 availability_zone_index
,
3643 availability_zone_list
,
3646 mock_reload_connection
.assert_called_once()
3647 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3652 external_network
=[],
3653 no_secured_ports
=[],
3655 mock_create_user_data
.assert_called_once_with(cloud_config
)
3656 mock_get_vm_availability_zone
.assert_called_once_with(
3657 availability_zone_index
, availability_zone_list
3659 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3661 existing_vim_volumes
=[],
3664 block_device_mapping
={},
3665 disk_list
=disk_list2
,
3668 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3673 security_groups
="default",
3674 availability_zone
="nova",
3675 key_name
="my_keypair",
3676 userdata
="userdata",
3678 block_device_mapping
={},
3681 mock_time
.assert_not_called()
3682 mock_update_port_security
.assert_not_called()
3683 mock_prepare_external_network
.assert_not_called()
3684 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3685 mock_delete_vm_instance
.assert_called_once_with(None, {})
3686 mock_format_exception
.assert_called_once()
3687 arg
= mock_format_exception
.call_args
[0][0]
3688 self
.assertEqual(str(arg
), "Server could not be created.")
3691 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3692 @patch.object(vimconnector
, "_reload_connection")
3693 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3694 @patch.object(vimconnector
, "_create_user_data")
3695 @patch.object(vimconnector
, "_get_vm_availability_zone")
3696 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3697 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3698 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3699 @patch.object(vimconnector
, "delete_vminstance")
3700 @patch.object(vimconnector
, "_format_exception")
3701 def test_new_vm_instance_connection_exception(
3703 mock_format_exception
,
3704 mock_delete_vm_instance
,
3705 mock_prepare_external_network
,
3706 mock_update_port_security
,
3707 mock_prepare_disk_for_vm_instance
,
3708 mock_get_vm_availability_zone
,
3709 mock_create_user_data
,
3710 mock_prepare_network_for_vm_instance
,
3711 mock_reload_connection
,
3712 mock_remove_keep_flag_from_persistent_volumes
,
3715 """Connection to Cloud API has failed."""
3716 mock_reload_connection
.side_effect
= Exception("Can not connect to Cloud APIs.")
3717 mock_create_user_data
.return_value
= True, "userdata"
3718 mock_get_vm_availability_zone
.return_value
= "nova"
3719 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3720 mock_time
.return_value
= time_return_value
3721 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3723 self
.vimconn
.new_vminstance(
3729 affinity_group_list
,
3733 availability_zone_index
,
3734 availability_zone_list
,
3736 mock_format_exception
.assert_called_once()
3737 arg
= mock_format_exception
.call_args
[0][0]
3738 self
.assertEqual(str(arg
), "Can not connect to Cloud APIs.")
3739 mock_reload_connection
.assert_called_once()
3740 mock_prepare_network_for_vm_instance
.assert_not_called()
3741 mock_create_user_data
.assert_not_called()
3742 mock_get_vm_availability_zone
.assert_not_called()
3743 mock_prepare_disk_for_vm_instance
.assert_not_called()
3744 self
.vimconn
.nova
.servers
.create
.assert_not_called()
3745 mock_time
.assert_not_called()
3746 mock_update_port_security
.assert_not_called()
3747 mock_prepare_external_network
.assert_not_called()
3748 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3749 mock_delete_vm_instance
.assert_called_once_with(None, {})
3751 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3752 def test_delete_vm_ports_attached_to_network_empty_created_items(
3753 self
, mock_delete_ports_by_id_wth_neutron
3755 """Created_items is emtpty."""
3757 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3758 self
.vimconn
.neutron
.list_ports
.assert_not_called()
3759 self
.vimconn
.neutron
.delete_port
.assert_not_called()
3760 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3762 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3763 def test_delete_vm_ports_attached_to_network(
3764 self
, mock_delete_ports_by_id_wth_neutron
3767 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
3768 f
"volume:{volume_id2}": True,
3769 f
"volume:{volume_id}": True,
3770 f
"port:{port_id}": True,
3772 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3773 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3774 self
.vimconn
.logger
.error
.assert_not_called()
3776 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3777 def test_delete_vm_ports_attached_to_network_wthout_port(
3778 self
, mock_delete_ports_by_id_wth_neutron
3780 """Created_items does not have port."""
3782 f
"floating_ip:{floating_network_vim_id}": True,
3783 f
"volume:{volume_id2}": True,
3784 f
"volume:{volume_id}": True,
3786 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3787 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
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_delete_port_raise_vimconnexception(
3792 self
, mock_delete_ports_by_id_wth_neutron
3794 """_delete_ports_by_id_wth_neutron raises vimconnexception."""
3795 created_items
= deepcopy(created_items_all_true
)
3796 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
3797 "Can not delete port"
3799 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3800 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3801 self
.vimconn
.logger
.error
.assert_called_once_with(
3802 "Error deleting port: VimConnException: Can not delete port"
3805 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3806 def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
3807 self
, mock_delete_ports_by_id_wth_neutron
3809 """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
3810 created_items
= deepcopy(created_items_all_true
)
3811 mock_delete_ports_by_id_wth_neutron
.side_effect
= nvExceptions
.ClientException(
3812 "Connection aborted."
3814 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3815 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3816 self
.vimconn
.logger
.error
.assert_called_once_with(
3817 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
3820 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3821 def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
3822 self
, mock_delete_ports_by_id_wth_neutron
3824 """port item is invalid."""
3826 f
"floating_ip:{floating_network_vim_id}": True,
3827 f
"volume:{volume_id2}": True,
3828 f
"volume:{volume_id}": True,
3829 f
"port:{port_id}:": True,
3831 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
3832 "Port is not valid."
3834 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3835 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}:")
3836 self
.vimconn
.logger
.error
.assert_called_once_with(
3837 "Error deleting port: VimConnException: Port is not valid."
3840 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3841 def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
3842 self
, mock_delete_ports_by_id_wth_neutron
3844 """port is already deleted."""
3846 f
"floating_ip:{floating_network_vim_id}": True,
3847 f
"volume:{volume_id2}": True,
3848 f
"volume:{volume_id}": None,
3849 f
"port:{port_id}": None,
3851 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3852 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3853 self
.vimconn
.logger
.error
.assert_not_called()
3855 def test_delete_floating_ip_by_id(self
):
3857 f
"floating_ip:{floating_network_vim_id}": True,
3858 f
"port:{port_id}": True,
3860 expected_created_items
= {
3861 f
"floating_ip:{floating_network_vim_id}": None,
3862 f
"port:{port_id}": True,
3864 k_id
= floating_network_vim_id
3865 k
= f
"floating_ip:{floating_network_vim_id}"
3866 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3867 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3868 self
.assertEqual(created_items
, expected_created_items
)
3870 def test_delete_floating_ip_by_id_floating_ip_already_deleted(self
):
3871 """floating ip is already deleted."""
3873 f
"floating_ip:{floating_network_vim_id}": None,
3874 f
"port:{port_id}": True,
3876 k_id
= floating_network_vim_id
3877 k
= f
"floating_ip:{floating_network_vim_id}"
3878 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3879 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3883 f
"floating_ip:{floating_network_vim_id}": None,
3884 f
"port:{port_id}": True,
3888 def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self
):
3889 """netron delete floating ip raises nvExceptions.ClientException."""
3891 f
"floating_ip:{floating_network_vim_id}": True,
3892 f
"port:{port_id}": True,
3894 k_id
= floating_network_vim_id
3895 k
= f
"floating_ip:{floating_network_vim_id}"
3896 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= (
3897 nvExceptions
.ClientException("Client exception occurred.")
3899 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3900 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3904 f
"floating_ip:{floating_network_vim_id}": True,
3905 f
"port:{port_id}": True,
3908 self
.vimconn
.logger
.error
.assert_called_once_with(
3909 "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occurred.)"
3912 def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self
):
3913 """netron delete floating ip raises VimConnNotFoundException."""
3915 f
"floating_ip:{floating_network_vim_id}": True,
3916 f
"port:{port_id}": True,
3918 k_id
= floating_network_vim_id
3919 k
= f
"floating_ip:{floating_network_vim_id}"
3920 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= VimConnNotFoundException(
3921 "Port id could not found."
3923 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3924 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3928 f
"floating_ip:{floating_network_vim_id}": True,
3929 f
"port:{port_id}": True,
3932 self
.vimconn
.logger
.error
.assert_called_once_with(
3933 "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
3936 def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self
):
3937 """invalid floating ip item."""
3939 f
"floating_ip:{floating_network_vim_id}": True,
3940 f
"port:{port_id}": True,
3942 expected_created_items
= {
3943 f
"floating_ip:{floating_network_vim_id}::": None,
3944 f
"floating_ip:{floating_network_vim_id}": True,
3945 f
"port:{port_id}": True,
3947 k_id
= floating_network_vim_id
3948 k
= f
"floating_ip:{floating_network_vim_id}::"
3949 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3950 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3951 self
.assertEqual(created_items
, expected_created_items
)
3953 def test_delete_volumes_by_id_with_cinder_volume_status_available(self
):
3954 """volume status is available."""
3956 f
"floating_ip:{floating_network_vim_id}": True,
3957 f
"volume:{volume_id2}": True,
3958 f
"volume:{volume_id}": True,
3959 f
"port:{port_id}": None,
3961 expected_created_items
= {
3962 f
"floating_ip:{floating_network_vim_id}": True,
3963 f
"volume:{volume_id2}": True,
3964 f
"volume:{volume_id}": None,
3965 f
"port:{port_id}": None,
3967 volumes_to_hold
= []
3968 k
= f
"volume:{volume_id}"
3970 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
3971 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
3972 k
, k_id
, volumes_to_hold
, created_items
3974 self
.assertEqual(result
, None)
3975 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
3976 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
3977 self
.vimconn
.logger
.error
.assert_not_called()
3978 self
.assertEqual(created_items
, expected_created_items
)
3980 def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self
):
3981 """volume is already deleted."""
3983 f
"floating_ip:{floating_network_vim_id}": True,
3984 f
"volume:{volume_id2}": True,
3985 f
"volume:{volume_id}": None,
3986 f
"port:{port_id}": None,
3988 expected_created_items
= {
3989 f
"floating_ip:{floating_network_vim_id}": True,
3990 f
"volume:{volume_id2}": True,
3991 f
"volume:{volume_id}": None,
3992 f
"port:{port_id}": None,
3994 volumes_to_hold
= []
3995 k
= f
"volume:{volume_id}"
3997 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
3998 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
3999 k
, k_id
, volumes_to_hold
, created_items
4001 self
.assertEqual(result
, None)
4002 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4003 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4004 self
.vimconn
.logger
.error
.assert_not_called()
4005 self
.assertEqual(created_items
, expected_created_items
)
4007 def test_delete_shared_volumes(self
):
4008 """cinder delete shared volumes"""
4009 shared_volume_vim_id
= volume_id4
4010 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4011 self
.vimconn
.delete_shared_volumes(shared_volume_vim_id
)
4012 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(shared_volume_vim_id
)
4013 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(shared_volume_vim_id
)
4014 self
.vimconn
.logger
.error
.assert_not_called()
4016 def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self
):
4017 """cinder get volume raises exception."""
4019 f
"floating_ip:{floating_network_vim_id}": True,
4020 f
"volume:{volume_id2}": True,
4021 f
"volume:{volume_id}": True,
4022 f
"port:{port_id}": None,
4024 expected_created_items
= {
4025 f
"floating_ip:{floating_network_vim_id}": True,
4026 f
"volume:{volume_id2}": True,
4027 f
"volume:{volume_id}": True,
4028 f
"port:{port_id}": None,
4030 volumes_to_hold
= []
4031 k
= f
"volume:{volume_id}"
4033 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception(
4034 "Can not get volume status."
4036 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4037 k
, k_id
, volumes_to_hold
, created_items
4039 self
.assertEqual(result
, None)
4040 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4041 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4042 self
.vimconn
.logger
.error
.assert_called_once_with(
4043 "Error deleting volume: Exception: Can not get volume status."
4045 self
.assertEqual(created_items
, expected_created_items
)
4047 def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self
):
4048 """cinder delete volume raises exception."""
4050 f
"floating_ip:{floating_network_vim_id}": True,
4051 f
"volume:{volume_id2}": True,
4052 f
"volume:{volume_id}": True,
4053 f
"port:{port_id}": None,
4055 expected_created_items
= {
4056 f
"floating_ip:{floating_network_vim_id}": True,
4057 f
"volume:{volume_id2}": True,
4058 f
"volume:{volume_id}": True,
4059 f
"port:{port_id}": None,
4061 volumes_to_hold
= []
4062 k
= f
"volume:{volume_id}"
4064 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4065 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= nvExceptions
.ClientException(
4066 "Connection aborted."
4068 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4069 k
, k_id
, volumes_to_hold
, created_items
4071 self
.assertEqual(result
, None)
4072 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4073 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4074 self
.vimconn
.logger
.error
.assert_called_once_with(
4075 "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
4077 self
.assertEqual(created_items
, expected_created_items
)
4079 def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self
):
4080 """volume_to_hold has item."""
4082 f
"floating_ip:{floating_network_vim_id}": True,
4083 f
"volume:{volume_id2}": True,
4084 f
"volume:{volume_id}": True,
4085 f
"port:{port_id}": None,
4087 expected_created_items
= {
4088 f
"floating_ip:{floating_network_vim_id}": True,
4089 f
"volume:{volume_id2}": True,
4090 f
"volume:{volume_id}": True,
4091 f
"port:{port_id}": None,
4093 volumes_to_hold
= [volume_id
]
4094 k
= f
"volume:{volume_id}"
4096 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4097 k
, k_id
, volumes_to_hold
, created_items
4099 self
.assertEqual(result
, None)
4100 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
4101 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4102 self
.vimconn
.logger
.error
.assert_not_called()
4103 self
.assertEqual(created_items
, expected_created_items
)
4105 def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self
):
4106 """volume status is not available."""
4108 f
"floating_ip:{floating_network_vim_id}": True,
4109 f
"volume:{volume_id2}": True,
4110 f
"volume:{volume_id}": True,
4111 f
"port:{port_id}": None,
4113 expected_created_items
= {
4114 f
"floating_ip:{floating_network_vim_id}": True,
4115 f
"volume:{volume_id2}": True,
4116 f
"volume:{volume_id}": True,
4117 f
"port:{port_id}": None,
4119 volumes_to_hold
= []
4120 k
= f
"volume:{volume_id}"
4122 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "unavailable"
4123 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4124 k
, k_id
, volumes_to_hold
, created_items
4126 self
.assertEqual(result
, True)
4127 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4128 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4129 self
.vimconn
.logger
.error
.assert_not_called()
4130 self
.assertEqual(created_items
, expected_created_items
)
4132 def test_delete_ports_by_id_by_neutron(self
):
4133 """neutron delete ports."""
4135 self
.vimconn
.neutron
.list_ports
.return_value
= {
4136 "ports": [{"id": port_id
}, {"id": port2_id
}]
4139 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4140 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4141 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4142 self
.vimconn
.logger
.error
.assert_not_called()
4144 def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self
):
4145 """port id not in the port list."""
4147 self
.vimconn
.neutron
.list_ports
.return_value
= {
4148 "ports": [{"id": port_id
}, {"id": port2_id
}]
4151 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4152 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4153 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4154 self
.vimconn
.logger
.error
.assert_not_called()
4156 def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self
):
4157 """neutron list port raises exception."""
4159 self
.vimconn
.neutron
.list_ports
.side_effect
= nvExceptions
.ClientException(
4160 "Connection aborted."
4162 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4163 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4164 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4165 self
.vimconn
.logger
.error
.assert_called_once_with(
4166 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4169 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
4170 """neutron delete port raises exception."""
4172 self
.vimconn
.neutron
.list_ports
.return_value
= {
4173 "ports": [{"id": port_id
}, {"id": port2_id
}]
4175 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
4176 "Connection aborted."
4178 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4179 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4180 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4181 self
.vimconn
.logger
.error
.assert_called_once_with(
4182 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4185 def test_get_item_name_id(self
):
4186 """Get name and id successfully."""
4187 k
= f
"some:{port_id}"
4188 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4189 self
.assertEqual(result
, ("some", f
"{port_id}"))
4191 def test_get_item_name_id_wthout_semicolon(self
):
4192 """Does not have seperator."""
4193 k
= f
"some{port_id}"
4194 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4195 self
.assertEqual(result
, (f
"some{port_id}", ""))
4197 def test_get_item_name_id_empty_string(self
):
4200 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4201 self
.assertEqual(result
, ("", ""))
4203 def test_get_item_name_id_k_is_none(self
):
4206 with self
.assertRaises(AttributeError):
4207 self
.vimconn
._get
_item
_name
_id
(k
)
4209 @patch.object(vimconnector
, "_get_item_name_id")
4210 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4211 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4212 def test_delete_created_items(
4214 mock_delete_floating_ip_by_id
,
4215 mock_delete_volumes_by_id_wth_cinder
,
4216 mock_get_item_name_id
,
4218 """Created items has floating ip and volume."""
4220 f
"floating_ip:{floating_network_vim_id}": True,
4221 f
"volume:{volume_id}": True,
4222 f
"port:{port_id}": None,
4224 mock_get_item_name_id
.side_effect
= [
4225 ("floating_ip", f
"{floating_network_vim_id}"),
4226 ("volume", f
"{volume_id}"),
4228 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4229 volumes_to_hold
= []
4230 keep_waiting
= False
4231 result
= self
.vimconn
._delete
_created
_items
(
4232 created_items
, volumes_to_hold
, keep_waiting
4234 self
.assertEqual(result
, True)
4235 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4236 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4237 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4239 mock_delete_floating_ip_by_id
.assert_called_once_with(
4240 f
"floating_ip:{floating_network_vim_id}",
4241 f
"{floating_network_vim_id}",
4244 self
.vimconn
.logger
.error
.assert_not_called()
4246 @patch.object(vimconnector
, "_get_item_name_id")
4247 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4248 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4249 def test_delete_created_items_wth_volumes_to_hold(
4251 mock_delete_floating_ip_by_id
,
4252 mock_delete_volumes_by_id_wth_cinder
,
4253 mock_get_item_name_id
,
4255 """Created items has floating ip and volume and volumes_to_hold has items."""
4257 f
"floating_ip:{floating_network_vim_id}": True,
4258 f
"volume:{volume_id}": True,
4259 f
"port:{port_id}": None,
4261 mock_get_item_name_id
.side_effect
= [
4262 ("floating_ip", f
"{floating_network_vim_id}"),
4263 ("volume", f
"{volume_id}"),
4265 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4266 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4267 keep_waiting
= False
4268 result
= self
.vimconn
._delete
_created
_items
(
4269 created_items
, volumes_to_hold
, keep_waiting
4271 self
.assertEqual(result
, True)
4272 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4273 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4274 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4276 mock_delete_floating_ip_by_id
.assert_called_once_with(
4277 f
"floating_ip:{floating_network_vim_id}",
4278 f
"{floating_network_vim_id}",
4281 self
.vimconn
.logger
.error
.assert_not_called()
4283 @patch.object(vimconnector
, "_get_item_name_id")
4284 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4285 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4286 def test_delete_created_items_wth_keep_waiting_true(
4288 mock_delete_floating_ip_by_id
,
4289 mock_delete_volumes_by_id_wth_cinder
,
4290 mock_get_item_name_id
,
4292 """Keep waiting initial value is True."""
4294 f
"floating_ip:{floating_network_vim_id}": True,
4295 f
"volume:{volume_id}": True,
4296 f
"port:{port_id}": None,
4298 mock_get_item_name_id
.side_effect
= [
4299 ("floating_ip", f
"{floating_network_vim_id}"),
4300 ("volume", f
"{volume_id}"),
4302 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4303 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4305 result
= self
.vimconn
._delete
_created
_items
(
4306 created_items
, volumes_to_hold
, keep_waiting
4308 self
.assertEqual(result
, True)
4309 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4310 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4311 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4313 mock_delete_floating_ip_by_id
.assert_called_once_with(
4314 f
"floating_ip:{floating_network_vim_id}",
4315 f
"{floating_network_vim_id}",
4318 self
.vimconn
.logger
.error
.assert_not_called()
4320 @patch.object(vimconnector
, "_get_item_name_id")
4321 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4322 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4323 def test_delete_created_items_delete_vol_raises(
4325 mock_delete_floating_ip_by_id
,
4326 mock_delete_volumes_by_id_wth_cinder
,
4327 mock_get_item_name_id
,
4329 """Delete volume raises exception."""
4331 f
"floating_ip:{floating_network_vim_id}": True,
4332 f
"volume:{volume_id}": True,
4333 f
"port:{port_id}": None,
4335 mock_get_item_name_id
.side_effect
= [
4336 ("floating_ip", f
"{floating_network_vim_id}"),
4337 ("volume", f
"{volume_id}"),
4339 mock_delete_volumes_by_id_wth_cinder
.side_effect
= ConnectionError(
4340 "Connection failed."
4342 volumes_to_hold
= []
4343 keep_waiting
= False
4344 result
= self
.vimconn
._delete
_created
_items
(
4345 created_items
, volumes_to_hold
, keep_waiting
4347 self
.assertEqual(result
, False)
4348 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4349 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4350 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4352 mock_delete_floating_ip_by_id
.assert_called_once_with(
4353 f
"floating_ip:{floating_network_vim_id}",
4354 f
"{floating_network_vim_id}",
4357 self
.vimconn
.logger
.error
.assert_called_once_with(
4358 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
4361 @patch.object(vimconnector
, "_get_item_name_id")
4362 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4363 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4364 def test_delete_created_items_delete_fip_raises(
4366 mock_delete_floating_ip_by_id
,
4367 mock_delete_volumes_by_id_wth_cinder
,
4368 mock_get_item_name_id
,
4370 """Delete floating ip raises exception."""
4372 f
"floating_ip:{floating_network_vim_id}": True,
4373 f
"volume:{volume_id}": True,
4374 f
"port:{port_id}": None,
4376 mock_get_item_name_id
.side_effect
= [
4377 ("floating_ip", f
"{floating_network_vim_id}"),
4378 ("volume", f
"{volume_id}"),
4380 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4381 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
4382 "Connection failed."
4384 volumes_to_hold
= []
4386 result
= self
.vimconn
._delete
_created
_items
(
4387 created_items
, volumes_to_hold
, keep_waiting
4389 self
.assertEqual(result
, True)
4390 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4391 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4392 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4394 mock_delete_floating_ip_by_id
.assert_called_once_with(
4395 f
"floating_ip:{floating_network_vim_id}",
4396 f
"{floating_network_vim_id}",
4399 self
.vimconn
.logger
.error
.assert_called_once_with(
4400 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
4403 @patch.object(vimconnector
, "_get_item_name_id")
4404 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4405 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4406 def test_delete_created_items_get_item_name_raises(
4408 mock_delete_floating_ip_by_id
,
4409 mock_delete_volumes_by_id_wth_cinder
,
4410 mock_get_item_name_id
,
4412 """Get item, name raises exception."""
4415 f
"volume{volume_id}": True,
4416 f
"port:{port_id}": None,
4418 mock_get_item_name_id
.side_effect
= [
4419 TypeError("Invalid Type"),
4420 AttributeError("Invalid attribute"),
4422 volumes_to_hold
= []
4423 keep_waiting
= False
4424 result
= self
.vimconn
._delete
_created
_items
(
4425 created_items
, volumes_to_hold
, keep_waiting
4427 self
.assertEqual(result
, False)
4428 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4429 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4430 mock_delete_floating_ip_by_id
.assert_not_called()
4431 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
4432 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
4435 (f
"Error deleting volume{volume_id}: Invalid attribute",),
4438 @patch.object(vimconnector
, "_get_item_name_id")
4439 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4440 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4441 def test_delete_created_items_no_fip_wth_port(
4443 mock_delete_floating_ip_by_id
,
4444 mock_delete_volumes_by_id_wth_cinder
,
4445 mock_get_item_name_id
,
4447 """Created items has port, does not have floating ip."""
4449 f
"volume:{volume_id}": True,
4450 f
"port:{port_id}": True,
4452 mock_get_item_name_id
.side_effect
= [
4453 ("volume", f
"{volume_id}"),
4454 ("port", f
"{port_id}"),
4456 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4457 volumes_to_hold
= []
4458 keep_waiting
= False
4459 result
= self
.vimconn
._delete
_created
_items
(
4460 created_items
, volumes_to_hold
, keep_waiting
4462 self
.assertEqual(result
, False)
4463 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4464 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4465 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4467 mock_delete_floating_ip_by_id
.assert_not_called()
4468 self
.vimconn
.logger
.error
.assert_not_called()
4470 @patch.object(vimconnector
, "_get_item_name_id")
4471 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4472 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4473 def test_delete_created_items_no_volume(
4475 mock_delete_floating_ip_by_id
,
4476 mock_delete_volumes_by_id_wth_cinder
,
4477 mock_get_item_name_id
,
4479 """Created items does not have volume."""
4481 f
"floating_ip:{floating_network_vim_id}": True,
4482 f
"port:{port_id}": None,
4484 mock_get_item_name_id
.side_effect
= [
4485 ("floating_ip", f
"{floating_network_vim_id}")
4487 volumes_to_hold
= []
4488 keep_waiting
= False
4489 result
= self
.vimconn
._delete
_created
_items
(
4490 created_items
, volumes_to_hold
, keep_waiting
4492 self
.assertEqual(result
, False)
4493 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
4494 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4495 mock_delete_floating_ip_by_id
.assert_called_once_with(
4496 f
"floating_ip:{floating_network_vim_id}",
4497 f
"{floating_network_vim_id}",
4500 self
.vimconn
.logger
.error
.assert_not_called()
4502 @patch.object(vimconnector
, "_get_item_name_id")
4503 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4504 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4505 def test_delete_created_items_already_deleted(
4507 mock_delete_floating_ip_by_id
,
4508 mock_delete_volumes_by_id_wth_cinder
,
4509 mock_get_item_name_id
,
4511 """All created items are alerady deleted."""
4513 f
"floating_ip:{floating_network_vim_id}": None,
4514 f
"volume:{volume_id}": None,
4515 f
"port:{port_id}": None,
4517 volumes_to_hold
= []
4518 keep_waiting
= False
4519 result
= self
.vimconn
._delete
_created
_items
(
4520 created_items
, volumes_to_hold
, keep_waiting
4522 self
.assertEqual(result
, False)
4523 mock_get_item_name_id
.assert_not_called()
4524 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4525 mock_delete_floating_ip_by_id
.assert_not_called()
4526 self
.vimconn
.logger
.error
.assert_not_called()
4528 @patch("time.sleep")
4529 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4530 @patch.object(vimconnector
, "_format_exception")
4531 @patch.object(vimconnector
, "_reload_connection")
4532 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4533 @patch.object(vimconnector
, "_delete_created_items")
4534 def test_delete_vminstance_successfully(
4536 mock_delete_created_items
,
4537 mock_delete_vm_ports_attached_to_network
,
4538 mock_reload_connection
,
4539 mock_format_exception
,
4540 mock_extract_items_wth_keep_flag_from_created_items
,
4543 vm_id
= f
"{virtual_mac_id}"
4544 created_items
= deepcopy(created_items_all_true
)
4545 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4546 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4547 mock_delete_created_items
.return_value
= False
4548 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4549 mock_reload_connection
.assert_called_once()
4550 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4551 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4552 mock_delete_created_items
.assert_called_once_with(
4553 created_items
, volumes_to_hold
, False
4555 mock_sleep
.assert_not_called()
4556 mock_format_exception
.assert_not_called()
4557 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4561 @patch("time.sleep")
4562 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4563 @patch.object(vimconnector
, "_format_exception")
4564 @patch.object(vimconnector
, "_reload_connection")
4565 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4566 @patch.object(vimconnector
, "_delete_created_items")
4567 def test_delete_vminstance_created_items_has_keep_flag(
4569 mock_delete_created_items
,
4570 mock_delete_vm_ports_attached_to_network
,
4571 mock_reload_connection
,
4572 mock_format_exception
,
4573 mock_extract_items_wth_keep_flag_from_created_items
,
4576 """Created_items includes items which has keep flag."""
4577 vm_id
= f
"{virtual_mac_id}"
4578 initial_created_items
= {
4579 f
"port{port_id}": True,
4580 f
"floating_ip{floating_network_vim_id}": None,
4581 f
"volume{volume_id}keep": True,
4582 f
"volume{volume_id2}keep": True,
4585 f
"port{port_id}": True,
4586 f
"floating_ip{floating_network_vim_id}": None,
4588 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4589 volumes_to_hold
= []
4590 mock_delete_created_items
.return_value
= False
4591 self
.vimconn
.delete_vminstance(vm_id
, initial_created_items
, volumes_to_hold
)
4592 mock_reload_connection
.assert_called_once()
4593 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4594 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4595 mock_delete_created_items
.assert_called_once_with(
4596 created_items
, volumes_to_hold
, False
4598 mock_sleep
.assert_not_called()
4599 mock_format_exception
.assert_not_called()
4600 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4601 initial_created_items
4604 @patch("time.sleep")
4605 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4606 @patch.object(vimconnector
, "_format_exception")
4607 @patch.object(vimconnector
, "_reload_connection")
4608 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4609 @patch.object(vimconnector
, "_delete_created_items")
4610 def test_delete_vminstance_extract_items_wth_keep_raises(
4612 mock_delete_created_items
,
4613 mock_delete_vm_ports_attached_to_network
,
4614 mock_reload_connection
,
4615 mock_format_exception
,
4616 mock_extract_items_wth_keep_flag_from_created_items
,
4619 """extract_items_wth_keep_flag_from_created_items raises AttributeError."""
4620 vm_id
= f
"{virtual_mac_id}"
4621 initial_created_items
= {
4622 f
"port{port_id}": True,
4623 f
"floating_ip{floating_network_vim_id}": None,
4624 f
"volume{volume_id}keep": True,
4625 f
"volume{volume_id2}keep": True,
4628 mock_extract_items_wth_keep_flag_from_created_items
.side_effect
= AttributeError
4629 volumes_to_hold
= []
4630 mock_delete_created_items
.return_value
= False
4631 with self
.assertRaises(AttributeError):
4632 self
.vimconn
.delete_vminstance(
4633 vm_id
, initial_created_items
, volumes_to_hold
4635 mock_reload_connection
.assert_not_called()
4636 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4637 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4638 mock_delete_created_items
.assert_not_called()
4639 mock_sleep
.assert_not_called()
4640 mock_format_exception
.assert_not_called()
4641 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4642 initial_created_items
4645 @patch("time.sleep")
4646 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4647 @patch.object(vimconnector
, "_format_exception")
4648 @patch.object(vimconnector
, "_reload_connection")
4649 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4650 @patch.object(vimconnector
, "_delete_created_items")
4651 def test_delete_vminstance_delete_created_items_raises(
4653 mock_delete_created_items
,
4654 mock_delete_vm_ports_attached_to_network
,
4655 mock_reload_connection
,
4656 mock_format_exception
,
4657 mock_extract_items_wth_keep_flag_from_created_items
,
4660 """Delete creted items raises exception."""
4661 vm_id
= f
"{virtual_mac_id}"
4662 created_items
= deepcopy(created_items_all_true
)
4663 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4664 mock_sleep
= MagicMock()
4665 volumes_to_hold
= []
4666 err
= ConnectionError("ClientException occurred.")
4667 mock_delete_created_items
.side_effect
= err
4668 with self
.assertRaises(ConnectionError
) as err
:
4669 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4670 self
.assertEqual(str(err
), "ClientException occurred.")
4671 mock_reload_connection
.assert_called_once()
4672 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4673 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4674 mock_delete_created_items
.assert_called_once()
4675 mock_sleep
.assert_not_called()
4676 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4680 @patch("time.sleep")
4681 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4682 @patch.object(vimconnector
, "_format_exception")
4683 @patch.object(vimconnector
, "_reload_connection")
4684 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4685 @patch.object(vimconnector
, "_delete_created_items")
4686 def test_delete_vminstance_delete_vm_ports_raises(
4688 mock_delete_created_items
,
4689 mock_delete_vm_ports_attached_to_network
,
4690 mock_reload_connection
,
4691 mock_format_exception
,
4692 mock_extract_items_wth_keep_flag_from_created_items
,
4695 """Delete vm ports raises exception."""
4696 vm_id
= f
"{virtual_mac_id}"
4697 created_items
= deepcopy(created_items_all_true
)
4698 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4699 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4700 err
= ConnectionError("ClientException occurred.")
4701 mock_delete_vm_ports_attached_to_network
.side_effect
= err
4702 mock_delete_created_items
.side_effect
= err
4703 with self
.assertRaises(ConnectionError
) as err
:
4704 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4705 self
.assertEqual(str(err
), "ClientException occurred.")
4706 mock_reload_connection
.assert_called_once()
4707 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4708 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4709 mock_delete_created_items
.assert_not_called()
4710 mock_sleep
.assert_not_called()
4711 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4715 @patch("time.sleep")
4716 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4717 @patch.object(vimconnector
, "_format_exception")
4718 @patch.object(vimconnector
, "_reload_connection")
4719 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4720 @patch.object(vimconnector
, "_delete_created_items")
4721 def test_delete_vminstance_nova_server_delete_raises(
4723 mock_delete_created_items
,
4724 mock_delete_vm_ports_attached_to_network
,
4725 mock_reload_connection
,
4726 mock_format_exception
,
4727 mock_extract_items_wth_keep_flag_from_created_items
,
4730 """Nova server delete raises exception."""
4731 vm_id
= f
"{virtual_mac_id}"
4732 created_items
= deepcopy(created_items_all_true
)
4733 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4734 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4735 err
= VimConnConnectionException("ClientException occurred.")
4736 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
4737 mock_delete_created_items
.side_effect
= err
4738 with self
.assertRaises(VimConnConnectionException
) as err
:
4739 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4740 self
.assertEqual(str(err
), "ClientException occurred.")
4741 mock_reload_connection
.assert_called_once()
4742 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4743 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4744 mock_delete_created_items
.assert_not_called()
4745 mock_sleep
.assert_not_called()
4746 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4750 @patch("time.sleep")
4751 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4752 @patch.object(vimconnector
, "_format_exception")
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_reload_connection_raises(
4758 mock_delete_created_items
,
4759 mock_delete_vm_ports_attached_to_network
,
4760 mock_reload_connection
,
4761 mock_format_exception
,
4762 mock_extract_items_wth_keep_flag_from_created_items
,
4765 """Reload connection raises exception."""
4766 vm_id
= f
"{virtual_mac_id}"
4767 created_items
= deepcopy(created_items_all_true
)
4768 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4769 mock_sleep
= MagicMock()
4770 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4771 err
= ConnectionError("ClientException occurred.")
4772 mock_delete_created_items
.return_value
= False
4773 mock_reload_connection
.side_effect
= err
4774 with self
.assertRaises(ConnectionError
) as err
:
4775 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4776 self
.assertEqual(str(err
), "ClientException occurred.")
4777 mock_reload_connection
.assert_called_once()
4778 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4779 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4780 mock_delete_created_items
.assert_not_called()
4781 mock_sleep
.assert_not_called()
4782 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4786 @patch("time.sleep")
4787 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4788 @patch.object(vimconnector
, "_format_exception")
4789 @patch.object(vimconnector
, "_reload_connection")
4790 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4791 @patch.object(vimconnector
, "_delete_created_items")
4792 def test_delete_vminstance_created_item_vol_to_hold_are_none(
4794 mock_delete_created_items
,
4795 mock_delete_vm_ports_attached_to_network
,
4796 mock_reload_connection
,
4797 mock_format_exception
,
4798 mock_extract_items_wth_keep_flag_from_created_items
,
4801 """created_items and volumes_to_hold are None."""
4802 vm_id
= f
"{virtual_mac_id}"
4803 created_items
= None
4804 volumes_to_hold
= None
4805 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= {}
4806 mock_delete_created_items
.return_value
= False
4807 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4808 mock_reload_connection
.assert_called_once()
4809 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4810 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4811 mock_delete_created_items
.assert_called_once_with({}, [], False)
4812 mock_sleep
.assert_not_called()
4813 mock_format_exception
.assert_not_called()
4814 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_vm_id_is_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 """vm_id is None."""
4833 created_items
= deepcopy(created_items_all_true
)
4834 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4835 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4836 mock_delete_created_items
.side_effect
= [True, True, 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_called_once_with(created_items
)
4840 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4841 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
4842 self
.assertEqual(mock_sleep
.call_count
, 2)
4843 mock_format_exception
.assert_not_called()
4844 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4848 @patch("time.sleep")
4849 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4850 @patch.object(vimconnector
, "_format_exception")
4851 @patch.object(vimconnector
, "_reload_connection")
4852 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4853 @patch.object(vimconnector
, "_delete_created_items")
4854 def test_delete_vminstance_delete_created_items_return_true(
4856 mock_delete_created_items
,
4857 mock_delete_vm_ports_attached_to_network
,
4858 mock_reload_connection
,
4859 mock_format_exception
,
4860 mock_extract_items_wth_keep_flag_from_created_items
,
4863 """Delete created items always return True."""
4865 created_items
= deepcopy(created_items_all_true
)
4866 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4867 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4868 mock_delete_created_items
.side_effect
= [True] * 1800
4869 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4870 mock_reload_connection
.assert_called_once()
4871 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4872 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4873 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
4874 self
.assertEqual(mock_sleep
.call_count
, 1800)
4875 mock_format_exception
.assert_not_called()
4876 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4880 def test_remove_keep_tag_from_persistent_volumes_keep_flag_exists(self
):
4881 """Keep flag exists in created items."""
4883 f
"port:{port_id}": True,
4884 f
"floating_ip:{floating_network_vim_id}": True,
4885 f
"volume:{volume_id}:keep": True,
4886 f
"volume:{volume_id2}:keep": True,
4889 f
"port:{port_id}": True,
4890 f
"floating_ip:{floating_network_vim_id}": True,
4891 f
"volume:{volume_id}": True,
4892 f
"volume:{volume_id2}": True,
4894 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4895 self
.assertDictEqual(result
, expected_result
)
4897 def test_remove_keep_tag_from_persistent_volumes_without_keep_flag(self
):
4898 """Keep flag does not exist in created items."""
4900 f
"port:{port_id}": True,
4901 f
"floating_ip:{floating_network_vim_id}": True,
4902 f
"volume:{volume_id}": True,
4903 f
"volume:{volume_id2}": True,
4905 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4906 self
.assertDictEqual(result
, created_items
)
4908 def test_update_block_device_mapping_empty_volume(self
):
4910 block_device_mapping
= {}
4911 base_disk_index
= 100
4914 with self
.assertRaises(VimConnException
) as err
:
4915 self
.vimconn
.update_block_device_mapping(
4916 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4918 self
.assertEqual(str(err
), "Volume is empty.")
4919 self
.assertEqual(block_device_mapping
, {})
4920 self
.assertEqual(created_items
, {})
4922 def test_update_block_device_mapping_invalid_volume(self
):
4924 block_device_mapping
= {}
4925 base_disk_index
= 100
4928 with self
.assertRaises(VimConnException
) as err
:
4929 self
.vimconn
.update_block_device_mapping(
4930 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4933 str(err
), "Created volume is not valid, does not have id attribute."
4935 self
.assertEqual(block_device_mapping
, {})
4936 self
.assertEqual(created_items
, {})
4938 def test_update_block_device_mapping(self
):
4939 volume
= MagicMock(autospec
=True)
4940 volume
.id = volume_id
4941 block_device_mapping
= {}
4942 base_disk_index
= 100
4945 self
.vimconn
.update_block_device_mapping(
4946 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4949 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4952 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a": True}
4955 def test_update_block_device_mapping_with_keep_flag(self
):
4956 volume
= MagicMock(autospec
=True)
4957 volume
.id = volume_id
4958 block_device_mapping
= {}
4959 base_disk_index
= 100
4960 disk
= {"size": 10, "keep": True}
4962 self
.vimconn
.update_block_device_mapping(
4963 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4966 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4969 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a:keep": True}
4972 def test_extract_items_with_keep_flag_item_has_keep_flag(self
):
4973 created_items
= deepcopy(created_items_all_true
)
4974 created_items
[f
"volume:{volume_id2}:keep"] = True
4975 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4978 self
.assertEqual(result
, deepcopy(created_items_all_true
))
4980 def test_extract_items_with_keep_flag_no_item_wth_keep_flag(self
):
4981 created_items
= deepcopy(created_items_all_true
)
4982 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4985 self
.assertEqual(result
, deepcopy(created_items_all_true
))
4987 def test_extract_items_with_keep_flag_all_items_are_already_deleted(self
):
4989 f
"port:{port_id}": None,
4990 f
"floating_ip:{floating_network_vim_id}": None,
4991 f
"volume:{volume_id}:keep": None,
4992 f
"volume:{volume_id2}:keep": None,
4995 f
"port:{port_id}": None,
4996 f
"floating_ip:{floating_network_vim_id}": None,
4998 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5001 self
.assertEqual(result
, expected_result
)
5003 def test_extract_items_with_keep_flag_without_semicolon(self
):
5005 f
"port{port_id}": True,
5006 f
"floating_ip{floating_network_vim_id}": None,
5007 f
"volume{volume_id}keep": True,
5008 f
"volume{volume_id2}keep": True,
5010 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5013 self
.assertEqual(result
, {})
5015 def test_extract_items_with_keep_flag_invalid_type_created_items(self
):
5016 created_items
= [{f
"port{port_id}": True}, {f
"volume{volume_id2}keep": True}]
5017 with self
.assertRaises(AttributeError):
5018 self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(created_items
)
5020 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5021 def test_get_monitoring_data(self
, mock_reload_conection
):
5022 servers
= ["server1", "server2"]
5023 ports
= {"ports": ["port1", "port2"]}
5024 self
.vimconn
.nova
.servers
.list.return_value
= servers
5025 self
.vimconn
.neutron
.list_ports
.return_value
= ports
5026 result
= self
.vimconn
.get_monitoring_data()
5027 self
.assertTupleEqual(result
, (servers
, ports
))
5028 mock_reload_conection
.assert_called_once()
5029 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5030 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5032 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5033 def test_get_monitoring_data_reload_connection_raises(self
, mock_reload_conection
):
5034 mock_reload_conection
.side_effect
= VimConnNotFoundException(
5035 "Connection object not found."
5037 with self
.assertRaises(VimConnException
) as err
:
5038 result
= self
.vimconn
.get_monitoring_data()
5039 self
.assertTupleEqual(result
, None)
5041 str(err
.exception
.args
[0]),
5042 "Exception in monitoring while getting VMs and ports status: Connection object not found.",
5044 mock_reload_conection
.assert_called_once()
5045 check_if_assert_not_called(
5046 [self
.vimconn
.nova
.servers
.list, self
.vimconn
.neutron
.list_ports
]
5049 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5050 def test_get_monitoring_data_server_list_raises(self
, mock_reload_conection
):
5051 self
.vimconn
.nova
.servers
.list.side_effect
= VimConnConnectionException(
5052 "Can not connect to Cloud API."
5054 with self
.assertRaises(VimConnException
) as err
:
5055 result
= self
.vimconn
.get_monitoring_data()
5056 self
.assertTupleEqual(result
, None)
5058 str(err
.exception
.args
[0]),
5059 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5061 mock_reload_conection
.assert_called_once()
5062 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5063 self
.vimconn
.neutron
.list_ports
.assert_not_called()
5065 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5066 def test_get_monitoring_data_list_ports_raises(self
, mock_reload_conection
):
5067 self
.vimconn
.neutron
.list_ports
.side_effect
= VimConnConnectionException(
5068 "Can not connect to Cloud API."
5070 with self
.assertRaises(VimConnException
) as err
:
5071 result
= self
.vimconn
.get_monitoring_data()
5072 self
.assertTupleEqual(result
, None)
5074 str(err
.exception
.args
[0]),
5075 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5077 mock_reload_conection
.assert_called_once()
5078 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5079 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5082 class TestNewFlavor(unittest
.TestCase
):
5083 @patch("logging.getLogger", autospec
=True)
5084 def setUp(self
, mock_logger
):
5085 # We are disabling the logging of exception not to print them to console.
5086 mock_logger
= logging
.getLogger()
5087 mock_logger
.disabled
= True
5088 self
.vimconn
= vimconnector(
5098 self
.vimconn
.nova
= CopyingMock(autospec
=True)
5099 self
.flavor1
= CopyingMock(autospec
=True, name
="sample-flavor")
5100 self
.flavor2
= CopyingMock(autospec
=True, name
="other-flavor")
5101 self
.new_flavor
= CopyingMock(autospec
=True, name
="new_flavor")
5102 self
.new_flavor
.id = "075d2482-5edb-43e3-91b3-234e65b6268a"
5103 self
.vimconn
.nova
.flavors
.create
.return_value
= self
.new_flavor
5105 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5106 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5107 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5110 "process_numa_paired_threads",
5111 new_callable
=CopyingMock(),
5113 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5114 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5115 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_vio(
5117 mock_process_numa_threads
,
5118 mock_process_numa_cores
,
5119 mock_process_numa_paired_threads
,
5120 mock_process_numa_vcpu
,
5121 mock_process_numa_memory
,
5122 mock_process_vio_numa_nodes
,
5124 """Process numa parameters, id, memory, vcpu exist, vim type is VIO,
5125 paired-threads, cores, threads do not exist in numa.
5128 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5129 {"id": 1, "memory": 2, "vcpu": [2]},
5132 expected_extra_specs
= {
5133 "hw:numa_nodes": "2",
5134 "hw:cpu_sockets": "2",
5136 self
.vimconn
.vim_type
= "VIO"
5137 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5139 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5140 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5141 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5142 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5144 _call_mock_process_numa_memory
[0].args
,
5146 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5149 "hw:numa_nodes": "2",
5154 _call_mock_process_numa_memory
[1].args
,
5156 {"id": 1, "memory": 2, "vcpu": [2]},
5159 "hw:cpu_sockets": "2",
5160 "hw:numa_nodes": "2",
5164 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5166 _call_mock_process_numa_vcpu
[0].args
,
5168 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5171 "hw:numa_nodes": "2",
5176 _call_mock_process_numa_vcpu
[1].args
,
5178 {"id": 1, "memory": 2, "vcpu": [2]},
5181 "hw:cpu_sockets": "2",
5182 "hw:numa_nodes": "2",
5186 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5187 check_if_assert_not_called(
5189 mock_process_numa_threads
,
5190 mock_process_numa_cores
,
5191 mock_process_numa_paired_threads
,
5195 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5196 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5197 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5200 "process_numa_paired_threads",
5201 new_callable
=CopyingMock(),
5203 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5204 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5205 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_openstack(
5207 mock_process_numa_threads
,
5208 mock_process_numa_cores
,
5209 mock_process_numa_paired_threads
,
5210 mock_process_numa_vcpu
,
5211 mock_process_numa_memory
,
5212 mock_process_vio_numa_nodes
,
5214 """Process numa parameters, id, memory, vcpu exist, vim type is openstack,
5215 paired-threads, cores, threads do not exist in numa.
5218 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5219 {"id": 1, "memory": 2, "vcpu": [2]},
5222 expected_extra_specs
= {
5223 "hw:numa_nodes": "2",
5224 "hw:cpu_sockets": "2",
5226 self
.vimconn
.vim_type
= "openstack"
5227 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5229 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5230 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5231 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5233 _call_mock_process_numa_memory
[0].args
,
5235 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5237 {"hw:numa_nodes": "2"},
5241 _call_mock_process_numa_memory
[1].args
,
5243 {"id": 1, "memory": 2, "vcpu": [2]},
5245 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5248 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5250 _call_mock_process_numa_vcpu
[0].args
,
5252 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5254 {"hw:numa_nodes": "2"},
5258 _call_mock_process_numa_vcpu
[1].args
,
5260 {"id": 1, "memory": 2, "vcpu": [2]},
5262 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5265 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5266 check_if_assert_not_called(
5268 mock_process_numa_threads
,
5269 mock_process_numa_cores
,
5270 mock_process_numa_paired_threads
,
5274 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5275 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5276 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5279 "process_numa_paired_threads",
5280 new_callable
=CopyingMock(),
5282 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5283 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5284 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_openstack_extra_spec_not_empty(
5286 mock_process_numa_threads
,
5287 mock_process_numa_cores
,
5288 mock_process_numa_paired_threads
,
5289 mock_process_numa_vcpu
,
5290 mock_process_numa_memory
,
5291 mock_process_vio_numa_nodes
,
5293 """Process numa parameters, id, paired-threads exist, vim type is openstack.
5294 vcpus calculation according to paired-threads in numa, there is extra_spec.
5296 numas
= [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
5297 extra_specs
= {"some-key": "some-value"}
5298 expected_extra_specs
= {
5299 "hw:cpu_sockets": "2",
5300 "hw:cpu_threads": "12",
5301 "hw:numa_nodes": "2",
5302 "some-key": "some-value",
5304 self
.vimconn
.vim_type
= "openstack"
5305 mock_process_numa_paired_threads
.side_effect
= [6, 6]
5306 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5308 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5309 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5310 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5311 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5312 _call_mock_process_numa_paired_threads
= (
5313 mock_process_numa_paired_threads
.call_args_list
5316 _call_mock_process_numa_paired_threads
[0].args
,
5318 {"id": 0, "paired-threads": 3},
5319 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5323 _call_mock_process_numa_paired_threads
[1].args
,
5325 {"id": 1, "paired-threads": 3},
5326 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5329 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5331 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5332 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5333 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5336 "process_numa_paired_threads",
5337 new_callable
=CopyingMock(),
5339 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5340 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5341 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_vio_extra_spec_not_empty(
5343 mock_process_numa_threads
,
5344 mock_process_numa_cores
,
5345 mock_process_numa_paired_threads
,
5346 mock_process_numa_vcpu
,
5347 mock_process_numa_memory
,
5348 mock_process_vio_numa_nodes
,
5350 """Process numa parameters, id, paired-threads exist, vim type is VIO.
5351 vcpus calculation according to paired-threads in numa, there is extra_spec.
5353 numas
= [{"id": 0, "paired-threads": 2}, {"id": 1, "paired-threads": 2}]
5354 extra_specs
= {"some-key": "some-value"}
5355 expected_extra_specs
= {
5356 "hw:numa_nodes": "2",
5357 "hw:cpu_sockets": "2",
5358 "hw:cpu_threads": "8",
5359 "some-key": "some-value",
5361 self
.vimconn
.vim_type
= "VIO"
5362 mock_process_numa_paired_threads
.side_effect
= [4, 4]
5363 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5364 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5365 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5366 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5367 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5368 _call_mock_process_numa_paired_threads
= (
5369 mock_process_numa_paired_threads
.call_args_list
5371 mock_process_vio_numa_nodes
.assert_called_once_with(
5372 2, {"some-key": "some-value", "hw:numa_nodes": "2"}
5375 _call_mock_process_numa_paired_threads
[0].args
,
5377 {"id": 0, "paired-threads": 2},
5379 "hw:cpu_sockets": "2",
5380 "hw:numa_nodes": "2",
5381 "some-key": "some-value",
5386 _call_mock_process_numa_paired_threads
[1].args
,
5388 {"id": 1, "paired-threads": 2},
5390 "hw:cpu_sockets": "2",
5391 "hw:numa_nodes": "2",
5392 "some-key": "some-value",
5396 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5398 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5399 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5400 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5403 "process_numa_paired_threads",
5404 new_callable
=CopyingMock(),
5406 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5407 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5408 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_openstack(
5410 mock_process_numa_threads
,
5411 mock_process_numa_cores
,
5412 mock_process_numa_paired_threads
,
5413 mock_process_numa_vcpu
,
5414 mock_process_numa_memory
,
5415 mock_process_vio_numa_nodes
,
5417 """Process numa parameters, id, cores exist, vim type is openstack.
5418 vcpus calculation according to cores in numa.
5420 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5422 updated_extra_specs
= {"hw:numa_nodes": "2", "hw:cpu_sockets": "2"}
5423 expected_extra_specs
= {
5424 "hw:numa_nodes": "2",
5425 "hw:cpu_sockets": "2",
5426 "hw:cpu_cores": "3",
5428 self
.vimconn
.vim_type
= "openstack"
5429 mock_process_numa_cores
.side_effect
= [1, 2]
5430 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5432 check_if_assert_not_called(
5433 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5435 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5436 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5437 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5438 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5440 _call_mock_process_numa_cores
[0].args
,
5441 ({"id": 0, "cores": 1}, updated_extra_specs
),
5444 _call_mock_process_numa_cores
[1].args
,
5445 ({"id": 1, "cores": 2}, updated_extra_specs
),
5447 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5449 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5450 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5451 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5454 "process_numa_paired_threads",
5455 new_callable
=CopyingMock(),
5457 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5458 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5459 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_vio(
5461 mock_process_numa_threads
,
5462 mock_process_numa_cores
,
5463 mock_process_numa_paired_threads
,
5464 mock_process_numa_vcpu
,
5465 mock_process_numa_memory
,
5466 mock_process_vio_numa_nodes
,
5468 """Process numa parameters, id, cores exist, vim type is VIO.
5469 vcpus calculation according to cores in numa.
5471 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5473 expected_extra_specs
= {
5474 "hw:cpu_cores": "3",
5475 "hw:cpu_sockets": "2",
5476 "hw:numa_nodes": "2",
5478 self
.vimconn
.vim_type
= "VIO"
5479 mock_process_numa_cores
.side_effect
= [1, 2]
5480 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5481 check_if_assert_not_called(
5482 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5484 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5485 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5486 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5487 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5488 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5490 _call_mock_process_numa_cores
[0].args
,
5492 {"id": 0, "cores": 1},
5494 "hw:cpu_sockets": "2",
5495 "hw:numa_nodes": "2",
5500 _call_mock_process_numa_cores
[1].args
,
5502 {"id": 1, "cores": 2},
5504 "hw:cpu_sockets": "2",
5505 "hw:numa_nodes": "2",
5509 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5511 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5512 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5513 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5516 "process_numa_paired_threads",
5517 new_callable
=CopyingMock(),
5519 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5520 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5521 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_vio(
5523 mock_process_numa_threads
,
5524 mock_process_numa_cores
,
5525 mock_process_numa_paired_threads
,
5526 mock_process_numa_vcpu
,
5527 mock_process_numa_memory
,
5528 mock_process_vio_numa_nodes
,
5530 """Process numa parameters, memory, vcpu, thread exist, vim type is VIO,
5531 vcpus calculation according threads in numa, there are not numa ids.
5534 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5535 {"memory": 2, "vcpu": [2]},
5538 expected_extra_specs
= {
5539 "hw:numa_nodes": "2",
5540 "hw:cpu_sockets": "2",
5541 "hw:cpu_threads": "3",
5543 self
.vimconn
.vim_type
= "VIO"
5544 mock_process_numa_threads
.return_value
= 3
5545 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5546 check_if_assert_not_called(
5548 mock_process_numa_memory
,
5549 mock_process_numa_vcpu
,
5550 mock_process_numa_cores
,
5551 mock_process_numa_paired_threads
,
5554 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5555 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5556 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5558 _call_mock_process_numa_threads
[0].args
,
5560 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5562 "hw:cpu_sockets": "2",
5563 "hw:numa_nodes": "2",
5567 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5569 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5570 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5571 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5574 "process_numa_paired_threads",
5575 new_callable
=CopyingMock(autospec
=True),
5577 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5578 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5579 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_openstack(
5581 mock_process_numa_threads
,
5582 mock_process_numa_cores
,
5583 mock_process_numa_paired_threads
,
5584 mock_process_numa_vcpu
,
5585 mock_process_numa_memory
,
5586 mock_process_vio_numa_nodes
,
5588 """Process numa parameters, memory, vcpu, thread exist, vim type is openstack,
5589 vcpus calculation according threads in numa, there are not numa ids.
5592 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5593 {"memory": 2, "vcpu": [2]},
5596 expected_extra_specs
= {
5597 "hw:numa_nodes": "2",
5598 "hw:cpu_sockets": "2",
5599 "hw:cpu_threads": "3",
5601 self
.vimconn
.vim_type
= "openstack"
5602 mock_process_numa_threads
.return_value
= 3
5603 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5605 check_if_assert_not_called(
5607 mock_process_numa_memory
,
5608 mock_process_numa_vcpu
,
5609 mock_process_numa_cores
,
5610 mock_process_numa_paired_threads
,
5611 mock_process_vio_numa_nodes
,
5614 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5615 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5617 _call_mock_process_numa_threads
[0].args
,
5619 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5620 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5623 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5625 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5626 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5627 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5630 "process_numa_paired_threads",
5631 new_callable
=CopyingMock(),
5633 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5634 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5635 def test_process_numa_parameters_of_flavor_empty_numas_list_type_vio(
5637 mock_process_numa_threads
,
5638 mock_process_numa_cores
,
5639 mock_process_numa_paired_threads
,
5640 mock_process_numa_vcpu
,
5641 mock_process_numa_memory
,
5642 mock_process_vio_numa_nodes
,
5644 """Numa list is empty, vim type is VIO."""
5647 expected_extra_specs
= {"hw:numa_nodes": "0"}
5648 self
.vimconn
.vim_type
= "VIO"
5649 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5650 check_if_assert_not_called(
5652 mock_process_numa_memory
,
5653 mock_process_numa_vcpu
,
5654 mock_process_numa_cores
,
5655 mock_process_numa_paired_threads
,
5656 mock_process_numa_threads
,
5659 mock_process_vio_numa_nodes
.assert_called_once_with(0, {"hw:numa_nodes": "0"})
5660 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5662 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5663 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5664 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5667 "process_numa_paired_threads",
5668 new_callable
=CopyingMock(),
5670 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5671 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5672 def test_process_numa_parameters_of_flavor_empty_numas_list_type_openstack(
5674 mock_process_numa_threads
,
5675 mock_process_numa_cores
,
5676 mock_process_numa_paired_threads
,
5677 mock_process_numa_vcpu
,
5678 mock_process_numa_memory
,
5679 mock_process_vio_numa_nodes
,
5681 """Numa list is empty, vim type is openstack."""
5684 expected_extra_specs
= {"hw:numa_nodes": "0"}
5685 self
.vimconn
.vim_type
= "openstack"
5686 mock_process_numa_threads
.return_value
= None
5687 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5689 check_if_assert_not_called(
5691 mock_process_numa_memory
,
5692 mock_process_numa_vcpu
,
5693 mock_process_numa_cores
,
5694 mock_process_numa_paired_threads
,
5695 mock_process_numa_threads
,
5696 mock_process_vio_numa_nodes
,
5699 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5701 def test_process_numa_memory_empty_extra_spec(self
):
5702 numa
= {"memory": 2, "vcpu": [2]}
5705 expected_extra_spec
= {"hw:numa_mem.2": 2048}
5706 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5707 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5709 def test_process_numa_memory_not_exist(self
):
5710 numa
= {"vcpu": [2]}
5712 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5713 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5714 self
.assertDictEqual(extra_specs
, {"vmware:latency_sensitivity_level": "high"})
5716 def test_process_numa_memory_node_id_is_none(self
):
5717 numa
= {"memory": 2, "vcpu": [2]}
5720 expected_extra_spec
= {"hw:numa_mem.None": 2048}
5721 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5722 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5724 def test_process_numa_vcpu_empty_extra_spec(self
):
5725 numa
= {"vcpu": [2]}
5728 expected_extra_spec
= {"hw:numa_cpus.0": "2"}
5729 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5730 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5732 def test_process_numa_vcpu_not_exist(self
):
5733 numa
= {"memory": 2}
5735 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5736 expected_extra_spec
= {"vmware:latency_sensitivity_level": "high"}
5737 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5738 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5740 def test_process_numa_vcpu_empty_node_id(self
):
5741 numa
= {"vcpu": [2]}
5744 expected_extra_spec
= {"hw:numa_cpus.": "2"}
5745 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5746 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5748 def test_process_numa_vcpu_empty_numa_dict(self
):
5752 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5753 self
.assertDictEqual(extra_specs
, {})
5755 def test_process_numa_vcpu_str_node_id(self
):
5756 numa
= {"vcpu": [2]}
5759 expected_extra_spec
= {"hw:numa_cpus.12": "2"}
5760 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5761 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5763 def test_process_numa_paired_threads_empty_extra_spec(self
):
5764 numa
= {"id": 0, "paired-threads": 3}
5766 expected_extra_spec
= {
5767 "hw:cpu_thread_policy": "require",
5768 "hw:cpu_policy": "dedicated",
5770 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5771 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5772 self
.assertEqual(result
, 6)
5774 def test_process_numa_paired_threads_empty_numa(self
):
5777 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5778 self
.assertDictEqual(extra_specs
, {})
5779 self
.assertEqual(result
, None)
5781 def test_process_numa_paired_threads_not_exist(self
):
5782 numa
= {"vcpu": [2]}
5784 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5785 self
.assertDictEqual(extra_specs
, {})
5786 self
.assertEqual(result
, None)
5788 def test_process_numa_paired_threads_str_thread_num(self
):
5789 numa
= {"id": 0, "paired-threads": "3"}
5791 expected_extra_spec
= {
5792 "hw:cpu_thread_policy": "require",
5793 "hw:cpu_policy": "dedicated",
5795 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5796 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5797 self
.assertEqual(result
, "33")
5799 def test_process_numa_paired_threads_none_thread_num(self
):
5800 numa
= {"id": 0, "paired-threads": None}
5802 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5803 self
.assertDictEqual(extra_specs
, {})
5804 self
.assertEqual(result
, None)
5806 def test_process_numa_cores_empty_extra_spec(self
):
5807 numa
= {"id": 0, "cores": 1}
5809 expected_extra_spec
= {
5810 "hw:cpu_policy": "dedicated",
5811 "hw:cpu_thread_policy": "isolate",
5813 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5814 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5815 self
.assertEqual(result
, 1)
5817 def test_process_numa_cores_not_exist(self
):
5818 numa
= {"id": 0, "paired-threads": 3}
5820 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5821 self
.assertDictEqual(extra_specs
, {})
5822 self
.assertEqual(result
, None)
5824 def test_process_numa_cores_empty_numa(self
):
5826 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5827 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5828 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5829 self
.assertEqual(result
, None)
5831 def test_process_numa_cores_none_core_num(self
):
5832 numa
= {"memory": 1, "cores": None}
5834 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5835 self
.assertDictEqual(extra_specs
, {})
5836 self
.assertEqual(result
, None)
5838 def test_process_numa_cores_string_core_num(self
):
5839 numa
= {"id": 0, "cores": "1"}
5840 extra_specs
= {"some-key": "some-val"}
5841 expected_extra_spec
= {
5842 "hw:cpu_policy": "dedicated",
5843 "hw:cpu_thread_policy": "isolate",
5844 "some-key": "some-val",
5846 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5847 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5848 self
.assertEqual(result
, "1")
5850 def test_process_numa_cores_float_core_num(self
):
5851 numa
= {"memory": 2, "cores": 10.03}
5852 extra_specs
= {"some-key": "some-val"}
5853 expected_extra_spec
= {
5854 "hw:cpu_policy": "dedicated",
5855 "hw:cpu_thread_policy": "isolate",
5856 "some-key": "some-val",
5858 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5859 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5860 self
.assertEqual(result
, 10.03)
5862 def test_process_numa_threads_empty_extra_spec_int_thread_num(self
):
5863 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3}
5865 expected_extra_spec
= {
5866 "hw:cpu_policy": "dedicated",
5867 "hw:cpu_thread_policy": "prefer",
5869 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5870 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5871 self
.assertEqual(result
, 3)
5873 def test_process_numa_threads_empty_numa(self
):
5875 extra_specs
= {"some-key": "some-val"}
5876 expected_extra_spec
= {"some-key": "some-val"}
5877 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5878 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5879 self
.assertEqual(result
, None)
5881 def test_process_numa_threads_not_exist(self
):
5882 numa
= {"memory": 1}
5883 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5884 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5885 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5886 self
.assertEqual(result
, None)
5888 def test_process_numa_threads_str_thread_num(self
):
5889 numa
= {"vcpu": [1, 3], "threads": "3"}
5891 expected_extra_spec
= {
5892 "hw:cpu_policy": "dedicated",
5893 "hw:cpu_thread_policy": "prefer",
5895 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5896 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5897 self
.assertEqual(result
, "3")
5899 def test_process_numa_threads_none_thread_num(self
):
5900 numa
= {"vcpu": [1, 3], "threads": None}
5902 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5903 self
.assertDictEqual(extra_specs
, {})
5904 self
.assertEqual(result
, None)
5906 def test_process_numa_threads_float_thread_num(self
):
5907 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3.3}
5908 extra_specs
= {"some-key": "some-val"}
5909 expected_extra_spec
= {
5910 "hw:cpu_policy": "dedicated",
5911 "hw:cpu_thread_policy": "prefer",
5912 "some-key": "some-val",
5914 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5915 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5916 self
.assertEqual(result
, 3.3)
5918 def test_change_the_flavor_name_not_existing_name(self
):
5919 """Flavor name does not exist in Openstack flavor list."""
5920 self
.flavor1
.name
= "sample-flavor-3"
5921 self
.flavor2
.name
= "other-flavor-4"
5922 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5923 name
= "other-flavor-3"
5925 flavor_data
= {"name": "other-flavor"}
5926 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5927 self
.assertEqual(result
, name
)
5928 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5929 # Checking whether name_suffix changed or not.
5930 self
.assertEqual(name_suffix
, 3)
5932 def test_change_the_flavor_name_existing_name(self
):
5933 """Flavor name exists in Openstack flavor list."""
5934 self
.flavor1
.name
= "other-flavor-6"
5935 self
.flavor2
.name
= "other-flavor-3"
5936 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5937 name
= "other-flavor-3"
5939 flavor_data
= {"name": "other-flavor"}
5940 expected_result
= "other-flavor-7"
5941 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5942 self
.assertEqual(result
, expected_result
)
5943 # Checking whether name_suffix changed or not.
5944 self
.assertEqual(name_suffix
, 5)
5945 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5947 def test_change_the_flavor_name_flavor_data_does_not_have_name(self
):
5948 """Flavor data does not have name."""
5949 self
.flavor1
.name
= "other-flavor-6"
5950 self
.flavor2
.name
= "other-flavor-3"
5951 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5952 name
= "other-flavor-3"
5955 with self
.assertRaises(KeyError):
5956 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5957 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5958 # Checking whether name_suffix changed or not.
5959 self
.assertEqual(name_suffix
, 5)
5961 def test_change_the_flavor_name_invalid_name_suffix(self
):
5962 """Name suffix is invalid."""
5963 self
.flavor1
.name
= "other-flavor-6"
5964 self
.flavor2
.name
= "other-flavor-3"
5965 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5966 name
= "other-flavor-3"
5968 flavor_data
= {"name": "other-flavor"}
5969 with self
.assertRaises(TypeError):
5970 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5971 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5972 # Checking whether name_suffix changed or not.
5973 self
.assertEqual(name_suffix
, "a")
5975 def test_change_the_flavor_name_given_name_is_empty(self
):
5976 """Given name is empty string."""
5977 self
.flavor1
.name
= "other-flavor-6"
5978 self
.flavor2
.name
= "other-flavor-3"
5979 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5982 flavor_data
= {"name": "other-flavor"}
5983 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5984 self
.assertEqual(result
, "")
5985 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5986 # Checking whether name_suffix increased or not.
5987 self
.assertEqual(name_suffix
, 3)
5989 def test_change_the_flavor_name_given_name_is_none(self
):
5990 """Given name is None."""
5991 self
.flavor1
.name
= "other-flavor-6"
5992 self
.flavor2
.name
= "other-flavor-3"
5993 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5996 flavor_data
= {"name": "other-flavor"}
5997 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5998 self
.assertEqual(result
, None)
5999 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6000 # Checking whether name_suffix increased or not.
6001 self
.assertEqual(name_suffix
, 6)
6003 def test_change_the_flavor_name_empty_nova_flavor_list(self
):
6004 """Nova flavor list is empty."""
6005 self
.vimconn
.nova
.flavors
.list.return_value
= []
6006 name
= "other-flavor-3"
6008 flavor_data
= {"name": "other-flavor"}
6009 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6010 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6011 self
.assertEqual(result
, name
)
6012 # Checking whether name_suffix increased or not.
6013 self
.assertEqual(name_suffix
, 5)
6017 "_process_numa_parameters_of_flavor",
6018 new_callable
=CopyingMock(),
6020 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6021 def test_process_extended_config_of_flavor_with_numa_cpu_mem_vif_disk_quota(
6022 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6024 """Process extended config, extended has numas, cpu, mem, vif and disk-io quota."""
6026 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6027 {"memory": 2, "vcpu": [2]},
6031 "cpu-quota": {"limit": 3},
6032 "mem-quota": {"limit": 1},
6033 "vif-quota": {"limit": 10},
6034 "disk-io-quota": {"limit": 50},
6035 "mempage-size": "LARGE",
6038 expected_extra_specs
= {
6039 "hw:mem_page_size": "large",
6041 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6043 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6044 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6045 self
.assertEqual(extra_specs
, expected_extra_specs
)
6049 "_process_numa_parameters_of_flavor",
6050 new_callable
=CopyingMock(),
6052 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6053 def test_process_extended_config_of_flavor_with_numa_wrong_disk_quota(
6054 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6056 """Process extended config, extended has wrong disk quota key."""
6058 {"memory": 1, "threads": 3},
6059 {"memory": 2, "vcpu": [2]},
6063 "disk-quota": {"limit": 50},
6064 "mempage-size": "PREFER_LARGE",
6067 expected_extra_specs
= {
6068 "hw:mem_page_size": "any",
6070 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6071 mock_process_resource_quota
.assert_not_called()
6072 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6073 self
.assertEqual(extra_specs
, expected_extra_specs
)
6077 "_process_numa_parameters_of_flavor",
6078 new_callable
=CopyingMock(),
6080 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6081 def test_process_extended_config_of_flavor_without_numa_cpu_mem_vif_disk_quota(
6082 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6084 """Process extended config, extended has cpu, mem, vif and disk-io quota but not numas."""
6086 "cpu-quota": {"limit": 3},
6087 "mem-quota": {"limit": 1},
6088 "vif-quota": {"limit": 10},
6089 "disk-io-quota": {"limit": 50},
6090 "mempage-size": "SMALL",
6093 expected_extra_specs
= {
6094 "hw:mem_page_size": "small",
6096 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6097 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6098 mock_process_numa_parameters_of_flavor
.assert_not_called()
6099 self
.assertEqual(extra_specs
, expected_extra_specs
)
6103 "_process_numa_parameters_of_flavor",
6104 new_callable
=CopyingMock(),
6106 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6107 def test_process_extended_config_of_flavor_with_numa_with_cpu_pinning_mem_policy(
6108 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6110 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy."""
6113 {"memory": 2, "vcpu": [2]},
6117 "cpu-quota": {"limit": 3},
6118 "mem-quota": {"limit": 1},
6119 "mempage-size": "LARGE",
6120 "cpu-pinning-policy": "DEDICATED",
6121 "mem-policy": "STRICT",
6124 expected_extra_specs
= {
6125 "hw:mem_page_size": "large",
6126 "hw:cpu_policy": "dedicated",
6127 "hw:numa_mempolicy": "strict",
6129 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6130 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6131 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6132 self
.assertEqual(extra_specs
, expected_extra_specs
)
6136 "_process_numa_parameters_of_flavor",
6137 new_callable
=CopyingMock(),
6139 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6140 def test_process_extended_config_of_flavor_without_numa_with_cpu_pinning_mem_policy(
6141 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6143 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy but not numas."""
6145 "cpu-quota": {"limit": 3},
6146 "mem-quota": {"limit": 1},
6147 "mempage-size": "LARGE",
6148 "cpu-pinning-policy": "DEDICATED",
6149 "mem-policy": "STRICT",
6152 expected_extra_specs
= {
6153 "hw:mem_page_size": "large",
6154 "hw:cpu_policy": "dedicated",
6155 "hw:numa_mempolicy": "strict",
6157 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6158 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6159 mock_process_numa_parameters_of_flavor
.assert_not_called()
6160 self
.assertEqual(extra_specs
, expected_extra_specs
)
6164 "_process_numa_parameters_of_flavor",
6165 new_callable
=CopyingMock(),
6167 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6168 def test_process_extended_config_of_flavor_without_numa_with_wrong_mempage_size(
6169 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6171 """Process extended config, extended has wrong mempage-size without numas."""
6173 "cpu-quota": {"limit": 3},
6174 "mem-quota": {"limit": 1},
6175 "mempage-size": "SIZE_2GB",
6176 "cpu-pinning-policy": "DEDICATED",
6177 "mem-policy": "STRICT",
6181 expected_extra_specs
= {
6182 "hw:cpu_policy": "dedicated",
6183 "hw:numa_mempolicy": "strict",
6185 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6186 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6187 mock_process_numa_parameters_of_flavor
.assert_not_called()
6188 self
.assertEqual(extra_specs
, expected_extra_specs
)
6192 "_process_numa_parameters_of_flavor",
6193 new_callable
=CopyingMock(),
6195 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6196 def test_process_extended_config_of_flavor_with_numa_with_wrong_mempage_size(
6197 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6199 """Process extended config, extended has wrong mempage-size with numas."""
6202 {"memory": 2, "vcpu": [2]},
6206 "cpu-quota": {"limit": 3},
6207 "mem-quota": {"limit": 1},
6208 "mempage-size": "SIZE_2GB",
6209 "cpu-pinning-policy": "DEDICATED",
6210 "mem-policy": "STRICT",
6213 expected_extra_specs
= {
6214 "hw:cpu_policy": "dedicated",
6215 "hw:numa_mempolicy": "strict",
6217 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6218 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6219 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6220 self
.assertEqual(extra_specs
, expected_extra_specs
)
6224 "_process_numa_parameters_of_flavor",
6225 new_callable
=CopyingMock(),
6227 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6228 def test_process_extended_config_of_flavor_none_vcpus(
6229 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6231 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6234 {"memory": 2, "vcpu": [2]},
6238 "cpu-quota": {"limit": 3},
6239 "mem-quota": {"limit": 1},
6240 "mempage-size": "SIZE_2GB",
6241 "cpu-pinning-policy": "DEDICATED",
6242 "mem-policy": "STRICT",
6245 expected_extra_specs
= {
6246 "hw:cpu_policy": "dedicated",
6247 "hw:numa_mempolicy": "strict",
6249 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6250 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6251 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6252 self
.assertEqual(extra_specs
, expected_extra_specs
)
6256 "_process_numa_parameters_of_flavor",
6257 new_callable
=CopyingMock(),
6259 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6260 def test_process_extended_config_of_flavor_none_vcpus_without_numas(
6261 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6263 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6265 "cpu-quota": {"limit": 3},
6266 "mem-quota": {"limit": 1},
6267 "mempage-size": "SIZE_2GB",
6268 "cpu-pinning-policy": "DEDICATED",
6269 "mem-policy": "STRICT",
6271 extra_specs
= {"some-key": "some-val"}
6272 expected_extra_specs
= {
6273 "hw:cpu_policy": "dedicated",
6274 "hw:numa_mempolicy": "strict",
6275 "some-key": "some-val",
6277 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6278 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6279 mock_process_numa_parameters_of_flavor
.assert_not_called()
6280 self
.assertEqual(extra_specs
, expected_extra_specs
)
6284 "_process_numa_parameters_of_flavor",
6285 new_callable
=CopyingMock(),
6287 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6288 def test_process_extended_config_of_flavor_wrong_cpu_pinning_mem_policy_empty_vcpus(
6289 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6291 """Process extended config, extended has wrong cpu-pinning and mem-policy keys."""
6294 {"memory": 2, "vcpu": [2]},
6298 "cpu-quota": {"limit": 3},
6299 "mem-quota": {"limit": 1},
6300 "mempage-size": "SIZE_2GB",
6301 "cpu-pinning-pol": "DEDICATED",
6302 "mem-pol": "STRICT",
6305 expected_extra_specs
= {}
6306 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6307 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6308 mock_process_numa_parameters_of_flavor
.assert_called_once_with(
6311 self
.assertEqual(extra_specs
, expected_extra_specs
)
6315 "_process_numa_parameters_of_flavor",
6316 new_callable
=CopyingMock(),
6318 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6319 def test_process_extended_config_of_flavor_empty_extended(
6320 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6322 """Process extended config, extended is empty."""
6325 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6326 check_if_assert_not_called(
6327 [mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
]
6329 self
.assertEqual(extra_specs
, {})
6331 def test_get_flavor_details_empty_flavor_data(self
):
6333 expected_result
= (64, 1, {}, None)
6334 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6335 self
.assertEqual(result
, expected_result
)
6337 def test_get_flavor_details_flavor_data_has_ram_vcpus_extended(self
):
6342 "some-key": "some-val",
6345 expected_result
= (32, 3, {}, {"some-key": "some-val"})
6346 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6347 self
.assertEqual(result
, expected_result
)
6349 def test_get_flavor_details_flavor_data_is_none(self
):
6351 with self
.assertRaises(AttributeError):
6352 self
.vimconn
._get
_flavor
_details
(flavor_data
)
6354 def test_get_flavor_details_flavor_data_has_only_extended(self
):
6357 "some-key": "some-val",
6360 expected_result
= (64, 1, {}, {"some-key": "some-val"})
6361 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6362 self
.assertEqual(result
, expected_result
)
6364 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6367 "_process_extended_config_of_flavor",
6368 new_callable
=CopyingMock(),
6370 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6371 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6372 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6373 def test_new_flavor_with_extended_with_extra_specs(
6375 mock_format_exception
,
6376 mock_reload_connection
,
6377 mock_change_flavor_name
,
6378 mock_extended_config_of_flavor
,
6379 mock_get_flavor_details
,
6381 """Create new flavor with using extended parameters and extra specs."""
6384 mock_change_flavor_name
.return_value
= name1
6385 mock_get_flavor_details
.return_value
= (
6388 {"some-key": "some-value"},
6391 expected_result
= self
.new_flavor
.id
6392 result
= self
.vimconn
.new_flavor(flavor_data
)
6393 self
.assertEqual(result
, expected_result
)
6394 mock_reload_connection
.assert_called_once()
6395 self
.new_flavor
.set_keys
.assert_called_once()
6396 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6397 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6398 mock_extended_config_of_flavor
.assert_called_once_with(
6399 extended
, {"some-key": "some-value"}
6401 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6402 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6404 mock_format_exception
.assert_not_called()
6406 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6409 "_process_extended_config_of_flavor",
6410 new_callable
=CopyingMock(),
6412 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6413 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6414 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6415 def test_new_flavor_with_extended_without_extra_specs(
6417 mock_format_exception
,
6418 mock_reload_connection
,
6419 mock_change_flavor_name
,
6420 mock_extended_config_of_flavor
,
6421 mock_get_flavor_details
,
6423 """Create new flavor with using extended parameters without extra specs."""
6426 mock_change_flavor_name
.return_value
= name1
6427 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6428 expected_result
= self
.new_flavor
.id
6429 result
= self
.vimconn
.new_flavor(flavor_data
)
6430 self
.assertEqual(result
, expected_result
)
6431 mock_reload_connection
.assert_called_once()
6432 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6433 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6434 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6435 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6436 name
=name1
, ram
=3, vcpus
=vcpus
, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6438 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6440 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6443 "_process_extended_config_of_flavor",
6444 new_callable
=CopyingMock(),
6446 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6447 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6448 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6449 def test_new_flavor_change_name_if_used_false_with_extended(
6451 mock_format_exception
,
6452 mock_reload_connection
,
6453 mock_change_flavor_name
,
6454 mock_extended_config_of_flavor
,
6455 mock_get_flavor_details
,
6457 """Create new flavor, change_name_if_used_false, there is extended."""
6459 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6460 expected_result
= self
.new_flavor
.id
6461 result
= self
.vimconn
.new_flavor(flavor_data
, False)
6462 self
.assertEqual(result
, expected_result
)
6463 mock_reload_connection
.assert_called_once()
6464 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6465 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6466 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6467 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6469 check_if_assert_not_called(
6470 [mock_change_flavor_name
, mock_format_exception
, self
.new_flavor
.set_keys
]
6473 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6476 "_process_extended_config_of_flavor",
6477 new_callable
=CopyingMock(),
6479 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6480 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6481 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6482 def test_new_flavor_change_name_if_used_true_without_extended(
6484 mock_format_exception
,
6485 mock_reload_connection
,
6486 mock_change_flavor_name
,
6487 mock_extended_config_of_flavor
,
6488 mock_get_flavor_details
,
6490 """Create new flavor without extended parameters."""
6492 mock_change_flavor_name
.return_value
= name1
6493 expected_result
= self
.new_flavor
.id
6494 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6495 result
= self
.vimconn
.new_flavor(flavor_data2
)
6496 self
.assertEqual(result
, expected_result
)
6497 mock_reload_connection
.assert_called_once()
6498 mock_change_flavor_name
.assert_called_once_with(
6499 name1
, name_suffix
, flavor_data2
6501 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6502 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6503 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6505 check_if_assert_not_called(
6507 self
.new_flavor
.set_keys
,
6508 mock_extended_config_of_flavor
,
6509 mock_format_exception
,
6513 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6516 "_process_extended_config_of_flavor",
6517 new_callable
=CopyingMock(),
6519 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6520 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6521 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6522 def test_new_flavor_reload_connection_exception(
6524 mock_format_exception
,
6525 mock_reload_connection
,
6526 mock_change_flavor_name
,
6527 mock_extended_config_of_flavor
,
6528 mock_get_flavor_details
,
6530 """Create new flavor, reload connection exception occurred."""
6531 error_msg
= "Can not connect to client APIs."
6532 error
= nvExceptions
.ClientException(error_msg
)
6533 mock_change_flavor_name
.return_value
= name1
6534 mock_reload_connection
.side_effect
= error
6535 with self
.assertRaises(Exception) as err
:
6536 self
.vimconn
.new_flavor(flavor_data2
)
6537 self
.assertEqual(str(err
.exception
), "Can not connect to client APIs.")
6538 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6539 call_mock_format_exception
= mock_format_exception
.call_args
6541 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6543 check_if_assert_not_called(
6545 mock_change_flavor_name
,
6546 mock_get_flavor_details
,
6547 mock_extended_config_of_flavor
,
6548 self
.vimconn
.nova
.flavors
.create
,
6552 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6555 "_process_extended_config_of_flavor",
6556 new_callable
=CopyingMock(autospec
=True),
6558 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6559 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6560 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6561 def test_new_flavor_flavor_data_without_name(
6563 mock_format_exception
,
6564 mock_reload_connection
,
6565 mock_change_flavor_name
,
6566 mock_extended_config_of_flavor
,
6567 mock_get_flavor_details
,
6569 """Create new flavor, flavor data does not have name."""
6576 self
.vimconn
.new_flavor(flavor_data3
)
6577 mock_format_exception
.assert_called_once()
6578 call_mock_format_exception
= mock_format_exception
.call_args
6580 str(call_mock_format_exception
[0][0]), str(KeyError(error_msg
))
6582 check_if_assert_not_called(
6584 mock_reload_connection
,
6585 mock_change_flavor_name
,
6586 mock_get_flavor_details
,
6587 mock_extended_config_of_flavor
,
6588 self
.vimconn
.nova
.flavors
.create
,
6592 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6595 "_process_extended_config_of_flavor",
6596 new_callable
=CopyingMock(),
6598 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6599 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6600 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6601 def test_new_flavor_change_flavor_name_has_extended_conflict_exception_recovered_in_retry(
6603 mock_format_exception
,
6604 mock_reload_connection
,
6605 mock_change_flavor_name
,
6606 mock_extended_config_of_flavor
,
6607 mock_get_flavor_details
,
6609 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is extended config."""
6611 error_msg
= "Conflict has occurred while creating flavor name."
6612 error2
= nvExceptions
.Conflict(error_msg
)
6613 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6614 expected_result
= self
.new_flavor
.id
6615 mock_get_flavor_details
.return_value
= (3, 8, {}, extended
)
6616 result
= self
.vimconn
.new_flavor(flavor_data2
)
6617 self
.assertEqual(result
, expected_result
)
6618 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6619 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6620 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6621 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6622 self
.assertEqual(mock_extended_config_of_flavor
.call_count
, 1)
6623 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6624 name
="sample-flavor-3",
6632 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6634 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6637 "_process_extended_config_of_flavor",
6638 new_callable
=CopyingMock(),
6640 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6641 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6642 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6643 def test_new_flavor_change_flavor_name_without_extended_conflict_exception_recovered_in_retry(
6645 mock_format_exception
,
6646 mock_reload_connection
,
6647 mock_change_flavor_name
,
6648 mock_extended_config_of_flavor
,
6649 mock_get_flavor_details
,
6651 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is not extended config."""
6653 error2
= nvExceptions
.Conflict(
6654 "Conflict has occurred while creating flavor name."
6656 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6657 expected_result
= self
.new_flavor
.id
6658 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6659 result
= self
.vimconn
.new_flavor(flavor_data2
)
6660 self
.assertEqual(result
, expected_result
)
6661 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6662 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6663 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6664 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6665 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6666 name
="sample-flavor-3",
6674 check_if_assert_not_called(
6676 self
.new_flavor
.set_keys
,
6677 mock_extended_config_of_flavor
,
6678 mock_format_exception
,
6682 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6685 "_process_extended_config_of_flavor",
6686 new_callable
=CopyingMock(),
6688 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6689 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6690 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6691 def test_new_flavor_change_flavor_name_conflict_exception_change_name_if_used_false(
6693 mock_format_exception
,
6694 mock_reload_connection
,
6695 mock_change_flavor_name
,
6696 mock_extended_config_of_flavor
,
6697 mock_get_flavor_details
,
6699 """Create new flavor, nvExceptions.Conflict occurred,
6700 change_name_if_used is false."""
6701 change_name_if_used
= False
6702 error_msg
= "Conflict has occurred while creating flavor name."
6703 error2
= nvExceptions
.Conflict(error_msg
)
6704 mock_get_flavor_details
.return_value
= (4, 8, {}, None)
6705 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6706 with self
.assertRaises(Exception) as err
:
6707 self
.vimconn
.new_flavor(flavor_data2
, change_name_if_used
)
6708 self
.assertEqual(str(err
.exception
), error_msg
)
6709 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6710 self
.vimconn
.nova
.flavors
.create
.assert_called_with(
6711 name
="sample-flavor",
6719 self
.assertEqual(mock_get_flavor_details
.call_count
, 3)
6720 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6721 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6722 check_if_assert_not_called(
6723 [mock_change_flavor_name
, mock_extended_config_of_flavor
]
6725 _call_mock_format_exception
= mock_format_exception
.call_args
6727 str(_call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6729 self
.assertEqual(mock_format_exception
.call_count
, 3)
6731 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6734 "_process_extended_config_of_flavor",
6735 new_callable
=CopyingMock(),
6737 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6738 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6739 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6740 def test_new_flavor_client_exception_occurred_change_name_if_used_true(
6742 mock_format_exception
,
6743 mock_reload_connection
,
6744 mock_change_flavor_name
,
6745 mock_extended_config_of_flavor
,
6746 mock_get_flavor_details
,
6748 """Create new flavor, nvExceptions.ClientException occurred,
6749 change_name_if_used is true."""
6750 error_msg
= "Connection failed."
6751 error2
= nvExceptions
.ClientException(error_msg
)
6752 mock_change_flavor_name
.side_effect
= [
6757 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6758 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6759 with self
.assertRaises(Exception) as err
:
6760 self
.vimconn
.new_flavor(flavor_data2
)
6762 str(err
.exception
), "Conflict has occurred while creating flavor name."
6764 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6765 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 1)
6766 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6768 _call_mock_nova_create_flavor
[0][1],
6771 "name": "sample-flavor-3",
6782 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6783 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6784 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6786 _call_mock_change_flavor
[0][0],
6790 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6793 self
.assertEqual(mock_change_flavor_name
.call_count
, 1)
6794 mock_extended_config_of_flavor
.assert_not_called()
6795 call_mock_format_exception
= mock_format_exception
.call_args
6797 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6799 self
.assertEqual(mock_format_exception
.call_count
, 1)
6801 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6804 "_process_extended_config_of_flavor",
6805 new_callable
=CopyingMock(),
6807 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6808 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6809 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6810 def test_new_flavor_change_flavor_name_conflict_exception_occurred_change_name_if_used_true(
6812 mock_format_exception
,
6813 mock_reload_connection
,
6814 mock_change_flavor_name
,
6815 mock_extended_config_of_flavor
,
6816 mock_get_flavor_details
,
6818 """Create new flavor, nvExceptions.Conflict occurred,
6819 change_name_if_used is true."""
6820 error_msg
= "Conflict has occurred while creating flavor name."
6821 error2
= nvExceptions
.Conflict(error_msg
)
6822 mock_change_flavor_name
.side_effect
= [
6827 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6828 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6829 with self
.assertRaises(Exception) as err
:
6830 self
.vimconn
.new_flavor(flavor_data2
)
6831 self
.assertEqual(str(err
.exception
), error_msg
)
6832 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6833 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6834 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6836 _call_mock_nova_create_flavor
[0][1],
6839 "name": "sample-flavor-3",
6850 _call_mock_nova_create_flavor
[1][1],
6853 "name": "sample-flavor-4",
6864 _call_mock_nova_create_flavor
[2][1],
6867 "name": "sample-flavor-5",
6877 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6878 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6880 _call_mock_change_flavor
[0][0],
6884 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6888 _call_mock_change_flavor
[1][0],
6892 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6896 _call_mock_change_flavor
[2][0],
6900 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6903 self
.assertEqual(mock_change_flavor_name
.call_count
, 3)
6904 mock_extended_config_of_flavor
.assert_not_called()
6905 call_mock_format_exception
= mock_format_exception
.call_args
6907 str(call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6909 self
.assertEqual(mock_format_exception
.call_count
, 1)
6911 def test_process_process_vio_numa_nodes_without_numa_with_extra_spec(self
):
6913 extra_specs
= {"hw:numa_nodes": "0"}
6914 expected_extra_spec
= {
6915 "vmware:latency_sensitivity_level": "high",
6916 "hw:numa_nodes": "0",
6918 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6919 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6921 def test_process_process_vio_numa_nodes_list_type_numa_nodes_empty_extra_spec(self
):
6922 numa_nodes
= [7, 9, 4]
6924 expected_extra_spec
= {
6925 "vmware:latency_sensitivity_level": "high",
6927 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6928 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6930 def test_process_process_vio_numa_nodes_with_numa_with_extra_spec(self
):
6932 extra_specs
= {"hw:numa_nodes": "5"}
6933 expected_extra_spec
= {
6934 "vmware:latency_sensitivity_level": "high",
6935 "hw:numa_nodes": "5",
6937 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6938 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6940 def test_process_process_vio_numa_nodes_none_numa_nodes(self
):
6942 extra_specs
= {"hw:numa_nodes": "None"}
6943 expected_extra_spec
= {
6944 "vmware:latency_sensitivity_level": "high",
6945 "hw:numa_nodes": "None",
6947 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6948 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6950 def test_process_process_vio_numa_nodes_invalid_type_extra_specs(self
):
6953 with self
.assertRaises(TypeError):
6954 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6957 if __name__
== "__main__":