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
121 def __init__(self
, name
="", status
="", flavor
="", id=""):
128 class CopyingMock(MagicMock
):
129 def __call__(self
, *args
, **kwargs
):
130 args
= deepcopy(args
)
131 kwargs
= deepcopy(kwargs
)
132 return super(CopyingMock
, self
).__call
__(*args
, **kwargs
)
135 class TestNewVmInstance(unittest
.TestCase
):
136 @patch("logging.getLogger", autospec
=True)
137 def setUp(self
, mock_logger
):
138 # Instantiate dummy VIM connector so we can test it
139 # It throws exception because of dummy parameters,
140 # We are disabling the logging of exception not to print them to console.
141 mock_logger
= logging
.getLogger()
142 mock_logger
.disabled
= True
143 self
.vimconn
= vimconnector(
153 self
.vimconn
.neutron
= CopyingMock()
154 self
.vimconn
.nova
= CopyingMock()
155 self
.vimconn
.cinder
= CopyingMock()
156 self
.server
= MagicMock(object, autospec
=True)
157 self
.server
.tenant_id
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
158 self
.server
.id = "908b73-e9cc-5a6a-t270-82cc4811bd4a"
159 self
.vimconn
.config
["security_groups"] = "default"
160 self
.vimconn
.config
["keypair"] = "my_keypair"
161 self
.vimconn
.security_groups_id
= "12345"
162 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.32"
163 self
.vimconn
.logger
= CopyingMock()
165 @patch.object(vimconnector
, "_get_ids_from_name")
166 def test_prepare_port_dict_security_security_groups_exists_in_config(
169 """In VIM config security_groups exists, net port_security is True
170 no_port_security_extension does not exist.
172 self
.vimconn
.config
= {"security_groups": "example_security_group"}
173 net
= {"port_security": True}
175 result_dict
= {"security_groups": "12345"}
177 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
178 self
.assertDictEqual(result_dict
, port_dict
)
179 mock_get_ids
.assert_not_called()
181 @patch.object(vimconnector
, "_get_ids_from_name")
182 def test_prepare_port_dict_security_security_groups_exists_in_config_no_security_groups_id(
185 """In VIM config Security_groups exists, net port_security is True, vim security_groups_id does not exist,
186 no_port_security_extension does not exist.
188 self
.vimconn
.config
= {"security_groups": "example_security_group"}
189 self
.vimconn
.security_groups_id
= None
190 net
= {"port_security": True}
192 result_dict
= {"security_groups": None}
194 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
195 self
.assertDictEqual(result_dict
, port_dict
)
196 mock_get_ids
.assert_called()
198 @patch.object(vimconnector
, "_get_ids_from_name")
199 def test_prepare_port_dict_security_security_groups_exists_security_extension_true_in_config(
202 """In VIM config security_groups exists, net port_security is True, in VIM security_groups_id exists,
203 no_port_security_extension set to True.
205 self
.vimconn
.config
= {
206 "security_groups": "example_security_group",
207 "no_port_security_extension": True,
209 net
= {"port_security": True}
213 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
214 self
.assertDictEqual(result_dict
, port_dict
)
215 mock_get_ids
.assert_not_called()
217 @patch.object(vimconnector
, "_get_ids_from_name")
218 def test_prepare_port_dict_security_no_security_groups_in_config(
221 """In VIM config security_group does not exist, net port_security True, in VIM security_groups_id exists,
222 no_port_security_extension does not exist."""
223 self
.vimconn
.config
= {}
224 net
= {"port_security": True}
228 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
229 self
.assertDictEqual(result_dict
, port_dict
)
230 mock_get_ids
.assert_not_called()
232 @patch.object(vimconnector
, "_get_ids_from_name")
233 def test_prepare_port_dict_security_no_security_groups_security_extension_true_in_config(
236 """Security_group does not exist, net port_security is True, in VIM security_groups_id exists,
237 no_port_security_extension set to True."""
238 self
.vimconn
.config
= {"no_port_security_extension": True}
239 net
= {"port_security": True}
243 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
244 self
.assertDictEqual(result_dict
, port_dict
)
245 mock_get_ids
.assert_not_called()
247 @patch.object(vimconnector
, "_get_ids_from_name")
248 def test_prepare_port_dict_security_security_groups_exists_net_port_security_false(
251 """In VIM config security_group exists, net port_security False, security_groups_id exists,
252 no_port_security_extension does not exist."""
253 self
.vimconn
.config
= {"security_groups": "example_security_group"}
254 net
= {"port_security": False}
258 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
259 self
.assertDictEqual(result_dict
, port_dict
)
260 mock_get_ids
.assert_not_called()
262 @patch.object(vimconnector
, "_get_ids_from_name")
263 def test_prepare_port_dict_security_net_port_security_false_port_security_extension_true(
266 """In VIM config security_group exists, net port_security False, security_groups_id exists,
267 no_port_security_extension set to True."""
268 self
.vimconn
.config
= {
269 "security_groups": "example_security_group",
270 "no_port_security_extension": True,
272 net
= {"port_security": False}
276 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
277 self
.assertDictEqual(result_dict
, port_dict
)
278 mock_get_ids
.assert_not_called()
280 def test_prepare_port_dict_binding_net_type_virtual(self
):
281 """net type is virtual."""
282 net
= {"type": "virtual"}
285 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
286 self
.assertDictEqual(result_dict
, port_dict
)
288 def test_prepare_port_dict_binding_net_type_vf(self
):
289 """net type is VF, vim_type is not VIO."""
291 self
.vimconn
.vim_type
= None
293 result_dict
= {"binding:vnic_type": "direct"}
294 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
295 self
.assertDictEqual(port_dict
, result_dict
)
297 def test_prepare_port_dict_binding_net_type_sriov_vim_type_vio(self
):
298 """net type is SR-IOV, vim_type is VIO."""
299 net
= {"type": "SR-IOV"}
300 self
.vimconn
.vim_type
= "VIO"
303 "binding:vnic_type": "direct",
304 "port_security_enabled": False,
305 "provider_security_groups": [],
306 "security_groups": [],
308 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
309 self
.assertDictEqual(port_dict
, result_dict
)
311 def test_prepare_port_dict_binding_net_type_passthrough(self
):
312 """net type is pci-passthrough."""
313 net
= {"type": "PCI-PASSTHROUGH"}
316 "binding:vnic_type": "direct-physical",
318 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
319 self
.assertDictEqual(port_dict
, result_dict
)
321 def test_prepare_port_dict_binding_no_net_type(self
):
322 """net type is missing."""
325 with self
.assertRaises(VimConnException
) as err
:
326 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
327 self
.assertEqual(str(err
.exception
), "Type is missing in the network details.")
329 def test_set_fixed_ip(self
):
330 """new_port has fixed ip."""
334 "fixed_ips": [{"ip_address": "10.1.2.3"}, {"ip_address": "20.1.2.3"}]
337 result
= {"ip": "10.1.2.3"}
338 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
339 self
.assertDictEqual(net
, result
)
341 def test_set_fixed_ip_no_fixed_ip(self
):
342 """new_port does not have fixed ip."""
344 new_port
= {"port": {}}
345 result
= {"ip": None}
346 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
347 self
.assertDictEqual(net
, result
)
349 def test_set_fixed_ip_raise_exception(self
):
350 """new_port does not have port details."""
353 with self
.assertRaises(Exception) as err
:
354 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
355 self
.assertEqual(type(err
.exception
), KeyError)
357 def test_prepare_port_dict_mac_ip_addr(self
):
358 """mac address and ip address exist."""
360 "mac_address": mac_address
,
361 "ip_address": "10.0.1.5",
365 "mac_address": mac_address
,
366 "fixed_ips": [{"ip_address": "10.0.1.5"}],
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_empty_net(self
):
372 """mac address and ip address does not exist."""
376 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
377 self
.assertDictEqual(port_dict
, result_dict
)
379 def test_prepare_port_dict_mac_ip_addr_dual(self
):
380 """mac address, ipv4 and ipv6 addresses exist."""
382 "mac_address": mac_address
,
383 "ip_address": ["10.0.1.5", "2345:0425:2CA1:0000:0000:0567:5673:23b5"],
387 "mac_address": mac_address
,
389 {"ip_address": "10.0.1.5"},
390 {"ip_address": "2345:0425:2CA1:0000:0000:0567:5673:23b5"},
393 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
394 self
.assertDictEqual(port_dict
, result_dict
)
396 def test_prepare_port_dict_mac_ip_addr_dual_ip_addr_is_not_list(self
):
397 """mac address, ipv4 and ipv6 addresses exist."""
399 "mac_address": mac_address
,
400 "ip_address": "10.0.1.5",
404 "mac_address": mac_address
,
406 {"ip_address": "10.0.1.5"},
409 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
410 self
.assertDictEqual(port_dict
, result_dict
)
412 def test_prepare_port_dict_mac_ip_addr_dual_net_without_ip_addr(self
):
413 """mac address, ipv4 and ipv6 addresses exist."""
415 "mac_address": mac_address
,
420 "mac_address": mac_address
,
422 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
423 self
.assertDictEqual(port_dict
, result_dict
)
425 def test_prepare_port_dict_mac_ip_addr_dual_net_without_mac_addr(self
):
426 """mac address, ipv4 and ipv6 addresses exist."""
428 "ip_address": ["10.0.1.5", "2345:0425:2CA1:0000:0000:0567:5673:23b5"],
433 {"ip_address": "10.0.1.5"},
434 {"ip_address": "2345:0425:2CA1:0000:0000:0567:5673:23b5"},
437 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
438 self
.assertDictEqual(port_dict
, result_dict
)
440 def test_create_new_port(self
):
441 """new port has id and mac address."""
445 "mac_address": mac_address
,
448 self
.vimconn
.neutron
.create_port
.return_value
= new_port
449 net
, port_dict
, created_items
= {}, {}, {}
450 expected_result
= new_port
452 "mac_address": mac_address
,
455 expected_created_items
= {f
"port:{port_id}": True}
456 result
= self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
457 self
.assertDictEqual(result
, expected_result
)
458 self
.assertEqual(net
, expected_net
)
459 self
.assertEqual(created_items
, expected_created_items
)
460 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
462 def test_create_new_port_without_mac_or_id(self
):
463 """new port does not have mac address or ID."""
465 self
.vimconn
.neutron
.create_port
.return_value
= new_port
466 net
, port_dict
, created_items
= {}, {}, {}
467 with self
.assertRaises(KeyError):
468 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
469 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
471 def test_create_new_port_neutron_create_port_raises_exception(self
):
472 """Neutron create port raises exception."""
473 self
.vimconn
.neutron
.create_port
.side_effect
= VimConnException(
474 "New port is not created."
476 net
, port_dict
, created_items
= {}, {}, {}
477 with self
.assertRaises(VimConnException
):
478 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
479 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
481 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
482 @patch.object(vimconnector
, "_prepare_port_dict_binding")
483 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
484 @patch.object(vimconnector
, "_create_new_port")
485 @patch.object(vimconnector
, "_set_fixed_ip")
486 def test_create_port(
489 mock_create_new_port
,
490 mock_prepare_port_dict_mac_ip_addr
,
491 mock_prepare_port_dict_binding
,
492 mock_prepare_port_dict_security_groups
,
494 """Net has name, type, net-id."""
498 "name": "management",
505 "mac_address": mac_address
,
506 "name": "management",
507 "fixed_ips": [{"ip_address": ip_addr1
}],
510 mock_create_new_port
.return_value
= new_port
516 "network_id": net_id
,
517 "name": "management",
518 "admin_state_up": True,
521 new_port_result
, port_result
= self
.vimconn
._create
_port
(
522 net
, name
, created_items
525 self
.assertDictEqual(new_port_result
, new_port
)
526 self
.assertDictEqual(port_result
, expected_port
)
528 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
529 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
530 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
531 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
532 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
534 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
535 @patch.object(vimconnector
, "_prepare_port_dict_binding")
536 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
537 @patch.object(vimconnector
, "_create_new_port")
538 @patch.object(vimconnector
, "_set_fixed_ip")
539 def test_create_port_no_port_name(
542 mock_create_new_port
,
543 mock_prepare_port_dict_mac_ip_addr
,
544 mock_prepare_port_dict_binding
,
545 mock_prepare_port_dict_security_groups
,
547 """Net has no name."""
556 "mac_address": mac_address
,
558 "fixed_ips": [{"ip_address": ip_addr1
}],
561 mock_create_new_port
.return_value
= new_port
567 "network_id": net_id
,
568 "admin_state_up": True,
572 new_port_result
, port_result
= self
.vimconn
._create
_port
(
573 net
, name
, created_items
576 self
.assertDictEqual(new_port_result
, new_port
)
577 self
.assertDictEqual(port_result
, expected_port
)
579 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
580 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
581 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
582 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
583 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
585 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
586 @patch.object(vimconnector
, "_prepare_port_dict_binding")
587 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
588 @patch.object(vimconnector
, "_create_new_port")
589 @patch.object(vimconnector
, "_set_fixed_ip")
590 def test_create_port_nova_api_version_smaller_than_232(
593 mock_create_new_port
,
594 mock_prepare_port_dict_mac_ip_addr
,
595 mock_prepare_port_dict_binding
,
596 mock_prepare_port_dict_security_groups
,
598 """Nova api version is smaller than 2.32."""
599 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.30"
608 "mac_address": mac_address
,
610 "fixed_ips": [{"ip_address": ip_addr1
}],
613 mock_create_new_port
.return_value
= new_port
618 "network_id": net_id
,
619 "admin_state_up": True,
623 new_port_result
, port_result
= self
.vimconn
._create
_port
(
624 net
, name
, created_items
627 self
.assertDictEqual(new_port_result
, new_port
)
628 self
.assertDictEqual(port_result
, expected_port
)
630 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
631 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
632 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
633 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
634 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
636 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
637 @patch.object(vimconnector
, "_prepare_port_dict_binding")
638 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
639 @patch.object(vimconnector
, "_create_new_port")
640 @patch.object(vimconnector
, "_set_fixed_ip")
641 def test_create_port_create_new_port_raise_exception(
644 mock_create_new_port
,
645 mock_prepare_port_dict_mac_ip_addr
,
646 mock_prepare_port_dict_binding
,
647 mock_prepare_port_dict_security_groups
,
649 """_create_new_port method raises exception."""
655 mock_create_new_port
.side_effect
= Exception
657 "network_id": net_id
,
658 "admin_state_up": True,
662 with self
.assertRaises(Exception):
663 self
.vimconn
._create
_port
(net
, name
, created_items
)
665 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
666 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
667 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
668 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
669 mock_set_fixed_ip
.assert_not_called()
671 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
672 @patch.object(vimconnector
, "_prepare_port_dict_binding")
673 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
674 @patch.object(vimconnector
, "_create_new_port")
675 @patch.object(vimconnector
, "_set_fixed_ip")
676 def test_create_port_create_sec_groups_raises_exception(
679 mock_create_new_port
,
680 mock_prepare_port_dict_mac_ip_addr
,
681 mock_prepare_port_dict_binding
,
682 mock_prepare_port_dict_security_groups
,
684 """_prepare_port_dict_security_groups method raises exception."""
690 mock_prepare_port_dict_security_groups
.side_effect
= Exception
692 "network_id": net_id
,
693 "admin_state_up": True,
697 with self
.assertRaises(Exception):
698 self
.vimconn
._create
_port
(net
, name
, created_items
)
700 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
702 mock_prepare_port_dict_binding
.assert_not_called()
703 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
704 mock_create_new_port
.assert_not_called()
705 mock_set_fixed_ip
.assert_not_called()
707 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
708 @patch.object(vimconnector
, "_prepare_port_dict_binding")
709 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
710 @patch.object(vimconnector
, "_create_new_port")
711 @patch.object(vimconnector
, "_set_fixed_ip")
712 def test_create_port_create_port_dict_binding_raise_exception(
715 mock_create_new_port
,
716 mock_prepare_port_dict_mac_ip_addr
,
717 mock_prepare_port_dict_binding
,
718 mock_prepare_port_dict_security_groups
,
720 """_prepare_port_dict_binding method raises exception."""
727 mock_prepare_port_dict_binding
.side_effect
= Exception
729 "network_id": net_id
,
730 "admin_state_up": True,
734 with self
.assertRaises(Exception):
735 self
.vimconn
._create
_port
(net
, name
, created_items
)
737 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
739 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
741 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
742 mock_create_new_port
.assert_not_called()
743 mock_set_fixed_ip
.assert_not_called()
745 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
746 @patch.object(vimconnector
, "_prepare_port_dict_binding")
747 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
748 @patch.object(vimconnector
, "_create_new_port")
749 @patch.object(vimconnector
, "_set_fixed_ip")
750 def test_create_port_create_port_mac_ip_addr_raise_exception(
753 mock_create_new_port
,
754 mock_prepare_port_dict_mac_ip_addr
,
755 mock_prepare_port_dict_binding
,
756 mock_prepare_port_dict_security_groups
,
758 """prepare_port_dict_mac_ip_addr method raises exception."""
764 mock_prepare_port_dict_mac_ip_addr
.side_effect
= Exception
766 "network_id": net_id
,
767 "admin_state_up": True,
771 with self
.assertRaises(Exception):
772 self
.vimconn
._create
_port
(net
, name
, created_items
)
774 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
775 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
776 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
778 mock_create_new_port
.assert_not_called()
779 mock_set_fixed_ip
.assert_not_called()
781 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
782 @patch.object(vimconnector
, "_prepare_port_dict_binding")
783 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
784 @patch.object(vimconnector
, "_create_new_port")
785 @patch.object(vimconnector
, "_set_fixed_ip")
786 def test_create_port_create_port_set_fixed_ip_raise_exception(
789 mock_create_new_port
,
790 mock_prepare_port_dict_mac_ip_addr
,
791 mock_prepare_port_dict_binding
,
792 mock_prepare_port_dict_security_groups
,
794 """_set_fixed_ip method raises exception."""
800 mock_set_fixed_ip
.side_effect
= VimConnException(
801 "Port detail is missing in new_port."
804 "network_id": net_id
,
805 "admin_state_up": True,
811 "mac_address": mac_address
,
813 "fixed_ips": [{"ip_address": ip_addr1
}],
816 mock_create_new_port
.return_value
= new_port
818 with self
.assertRaises(VimConnException
):
819 self
.vimconn
._create
_port
(net
, name
, created_items
)
821 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
822 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
823 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
824 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
825 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
827 @patch.object(vimconnector
, "_reload_connection")
828 @patch.object(vimconnector
, "_create_port")
829 def test_prepare_network_for_vm_instance_no_net_id(
830 self
, mock_create_port
, mock_reload_connection
832 """Nets do not have net_id"""
833 mock_reload_connection
.side_effect
= None
838 "port_security": False,
839 "exit_on_floating_ip_error": False,
840 "port_security_disable_strategy": "full",
843 "port_security": True,
844 "exit_on_floating_ip_error": False,
849 external_network
, no_secured_ports
= [], []
850 expected_external_network
, expected_no_secured_ports
= [], []
851 expected_net_list_vim
= []
853 self
.vimconn
._prepare
_network
_for
_vminstance
(
861 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
862 self
.assertEqual(external_network
, expected_external_network
)
863 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
865 mock_create_port
.assert_not_called()
867 @patch.object(vimconnector
, "_reload_connection")
868 @patch.object(vimconnector
, "_create_port")
869 def test_prepare_network_for_vm_instance_empty_net_list(
870 self
, mock_create_port
, mock_reload_connection
872 """Net list is empty."""
873 mock_reload_connection
.side_effect
= None
876 external_network
, no_secured_ports
= [], []
877 expected_external_network
, expected_no_secured_ports
= [], []
878 expected_net_list_vim
= []
880 self
.vimconn
._prepare
_network
_for
_vminstance
(
888 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
889 self
.assertEqual(external_network
, expected_external_network
)
890 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
892 mock_create_port
.assert_not_called()
894 @patch.object(vimconnector
, "_reload_connection")
895 @patch.object(vimconnector
, "_create_port")
896 def test_prepare_network_for_vm_instance_use_floating_ip_false_mgmt_net(
897 self
, mock_create_port
, mock_reload_connection
899 """Nets have net-id, floating_ip False, mgmt network."""
900 mock_reload_connection
.side_effect
= None
905 "floating_ip": False,
910 mock_create_port
.side_effect
= [
915 "mac_address": mac_address
,
919 {"port-dict": port2_id
},
922 external_network
, no_secured_ports
= [], []
923 expected_external_network
, expected_no_secured_ports
= [], []
924 expected_net_list_vim
= [{"port-dict": port2_id
}]
925 self
.vimconn
._prepare
_network
_for
_vminstance
(
933 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
934 self
.assertEqual(external_network
, expected_external_network
)
935 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
937 mock_create_port
.assert_called_once_with(
940 "floating_ip": False,
947 @patch.object(vimconnector
, "_reload_connection")
948 def test_prepare_network_for_vm_instance_mgmt_net_net_port_security_and_floating_ip_true(
949 self
, mock_reload_connection
951 """Nets have net-id, use_floating_ip False in VIM config, mgmt network, net floating_ip is True."""
952 self
.vimconn
.config
["use_floating_ip"] = False
953 mock_create_port
= CopyingMock()
954 mock_reload_connection
.side_effect
= None
964 mock_create_port
.side_effect
= [
969 "mac_address": mac_address
,
973 {"port-dict": port2_id
},
976 external_network
, no_secured_ports
= [], []
977 expected_external_network
= [
982 "exit_on_floating_ip_error": True,
985 expected_no_secured_ports
= []
986 expected_net_list_vim
= [{"port-dict": port2_id
}]
987 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
988 self
.vimconn
._prepare
_network
_for
_vminstance
(
996 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
997 self
.assertEqual(external_network
, expected_external_network
)
998 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1000 mock_create_port
.assert_called_once_with(
1003 "floating_ip": True,
1010 @patch.object(vimconnector
, "_reload_connection")
1011 def test_prepare_network_for_vm_instance_use_floating_ip_true_mgmt_net_port_security_false(
1012 self
, mock_reload_connection
1014 """Nets have net-id, use_floating_ip is True in VIM config, mgmt network, net port security is False."""
1015 mock_create_port
= CopyingMock()
1016 self
.vimconn
.config
["use_floating_ip"] = True
1017 self
.vimconn
.config
["no_port_security_extension"] = False
1018 mock_reload_connection
.side_effect
= None
1025 "port_security": False,
1026 "exit_on_floating_ip_error": False,
1027 "port_security_disable_strategy": "full",
1031 mock_create_port
.side_effect
= [
1036 "mac_address": mac_address
,
1040 {"port-dict": port2_id
},
1043 external_network
, no_secured_ports
= [], []
1044 expected_external_network
= [
1048 "port_security": False,
1049 "exit_on_floating_ip_error": False,
1050 "port_security_disable_strategy": "full",
1051 "floating_ip": True,
1054 expected_no_secured_ports
= [(port2_id
, "full")]
1055 expected_net_list_vim
= [{"port-dict": port2_id
}]
1056 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1057 self
.vimconn
._prepare
_network
_for
_vminstance
(
1066 mock_create_port
.assert_called_once_with(
1070 "port_security": False,
1071 "exit_on_floating_ip_error": False,
1072 "port_security_disable_strategy": "full",
1077 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1078 self
.assertEqual(external_network
, expected_external_network
)
1079 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1081 @patch.object(vimconnector
, "_reload_connection")
1082 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_false(
1083 self
, mock_reload_connection
1085 """Nets have net-id, use_floating_ip True in VIM config, non-mgmt network, port security is False."""
1086 mock_create_port
= CopyingMock()
1087 self
.vimconn
.config
["use_floating_ip"] = True
1088 self
.vimconn
.config
["no_port_security_extension"] = False
1089 mock_reload_connection
.side_effect
= None
1096 "port_security": False,
1097 "port_security_disable_strategy": "full",
1101 mock_create_port
.side_effect
= [
1106 "mac_address": mac_address
,
1110 {"port-dict": port2_id
},
1113 external_network
, no_secured_ports
= [], []
1114 expected_external_network
= []
1115 expected_no_secured_ports
= [(port2_id
, "full")]
1116 expected_net_list_vim
= [{"port-dict": port2_id
}]
1117 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1118 self
.vimconn
._prepare
_network
_for
_vminstance
(
1127 mock_create_port
.assert_called_once_with(
1131 "port_security": False,
1132 "port_security_disable_strategy": "full",
1137 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1138 self
.assertEqual(external_network
, expected_external_network
)
1139 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1141 @patch.object(vimconnector
, "_reload_connection")
1142 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_true(
1143 self
, mock_reload_connection
1145 """Nets have net-id, use_floating_ip is True in VIM config, non-mgmt network, net port security is True."""
1146 mock_create_port
= CopyingMock()
1147 self
.vimconn
.config
["use_floating_ip"] = True
1148 self
.vimconn
.config
["no_port_security_extension"] = True
1149 mock_reload_connection
.side_effect
= None
1156 "port_security": True,
1157 "port_security_disable_strategy": "full",
1161 mock_create_port
.side_effect
= [
1166 "mac_address": mac_address
,
1170 {"port-dict": port2_id
},
1173 external_network
, no_secured_ports
= [], []
1174 expected_external_network
= []
1175 expected_no_secured_ports
= []
1176 expected_net_list_vim
= [{"port-dict": port2_id
}]
1177 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1178 self
.vimconn
._prepare
_network
_for
_vminstance
(
1187 mock_create_port
.assert_called_once_with(
1191 "port_security": True,
1192 "port_security_disable_strategy": "full",
1197 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1198 self
.assertEqual(external_network
, expected_external_network
)
1199 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1201 @patch.object(vimconnector
, "_reload_connection")
1202 def test_prepare_network_for_vm_instance_create_port_raise_exception(
1203 self
, mock_reload_connection
1205 """_create_port method raise exception."""
1206 mock_create_port
= CopyingMock()
1207 self
.vimconn
.config
["use_floating_ip"] = True
1208 self
.vimconn
.config
["no_port_security_extension"] = True
1209 mock_reload_connection
.side_effect
= None
1216 "port_security": True,
1217 "port_security_disable_strategy": "full",
1221 mock_create_port
.side_effect
= KeyError
1222 external_network
, no_secured_ports
= [], []
1223 expected_external_network
= []
1224 expected_no_secured_ports
= []
1225 expected_net_list_vim
= []
1226 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1227 with self
.assertRaises(Exception) as err
:
1228 self
.vimconn
._prepare
_network
_for
_vminstance
(
1237 self
.assertEqual(type(err
.exception
), KeyError)
1239 mock_create_port
.assert_called_once_with(
1243 "port_security": True,
1244 "port_security_disable_strategy": "full",
1249 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1250 self
.assertEqual(external_network
, expected_external_network
)
1251 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1253 @patch.object(vimconnector
, "_reload_connection")
1254 def test_prepare_network_for_vm_instance_reload_connection_raise_exception(
1255 self
, mock_reload_connection
1257 """_reload_connection method raises exception."""
1258 mock_create_port
= CopyingMock()
1259 mock_reload_connection
.side_effect
= VimConnConnectionException(
1260 "Connection failed."
1262 self
.vimconn
.config
["use_floating_ip"] = True
1263 self
.vimconn
.config
["no_port_security_extension"] = True
1270 "port_security": True,
1271 "port_security_disable_strategy": "full",
1275 mock_create_port
.side_effect
= None
1276 external_network
, no_secured_ports
= [], []
1277 expected_external_network
= []
1278 expected_no_secured_ports
= []
1279 expected_net_list_vim
= []
1280 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1281 with self
.assertRaises(Exception) as err
:
1282 self
.vimconn
._prepare
_network
_for
_vminstance
(
1291 self
.assertEqual(type(err
.exception
), VimConnConnectionException
)
1292 self
.assertEqual(str(err
.exception
), "Connection failed.")
1293 mock_reload_connection
.assert_called_once()
1294 mock_create_port
.assert_not_called()
1295 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1296 self
.assertEqual(external_network
, expected_external_network
)
1297 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1299 def test_prepare_persistent_root_volumes_vim_using_volume_id(self
):
1300 """Existing persistent root volume with vim_volume_id."""
1301 vm_av_zone
= ["nova"]
1302 base_disk_index
= ord("a")
1303 disk
= {"vim_volume_id": volume_id
}
1304 block_device_mapping
= {}
1305 existing_vim_volumes
= []
1307 expected_boot_vol_id
= None
1308 expected_block_device_mapping
= {"vda": volume_id
}
1309 expected_existing_vim_volumes
= [{"id": volume_id
}]
1310 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1315 block_device_mapping
,
1316 existing_vim_volumes
,
1319 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1320 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1321 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1322 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1324 @patch.object(vimconnector
, "update_block_device_mapping")
1325 def test__prepare_shared_volumes_vim_using_volume_id(
1326 self
, mock_update_block_device_mapping
1328 """Existing persistent non root volume with vim_volume_id.
1330 def __init__(self, s, type="__DEFAULT__", name="", id=""):
1332 self.volume_type = type
1335 volumes = {"shared-volume": volume_id4}
1337 The device mappeing BEFORE is: {}
1338 The device mappeing AFTER is: {'vdb': '8ca50cc6-a779-4513-a1f3-900b8b3987d2'}
1340 base_disk_index
= ord("b")
1341 disk
= {"name": "shared-volume"}
1342 block_device_mapping
= {}
1343 existing_vim_volumes
= []
1345 expected_block_device_mapping
= {}
1346 self
.vimconn
.cinder
.volumes
.list.return_value
= [
1347 Volume("avaible", "multiattach", "shared-volume", volume_id4
)
1349 self
.vimconn
.cinder
.volumes
.get
.return_value
.id = volume_id4
1350 self
.vimconn
._prepare
_shared
_volumes
(
1354 block_device_mapping
,
1355 existing_vim_volumes
,
1358 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id4
)
1359 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1361 @patch.object(vimconnector
, "update_block_device_mapping")
1362 def test_prepare_persistent_non_root_volumes_vim_using_volume_id(
1363 self
, mock_update_block_device_mapping
1365 """Existing persistent non root volume with vim_volume_id."""
1366 vm_av_zone
= ["nova"]
1367 base_disk_index
= ord("b")
1368 disk
= {"vim_volume_id": volume_id
}
1369 block_device_mapping
= {}
1370 existing_vim_volumes
= []
1372 expected_block_device_mapping
= {"vdb": volume_id
}
1373 expected_existing_vim_volumes
= [{"id": volume_id
}]
1374 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1378 block_device_mapping
,
1380 existing_vim_volumes
,
1383 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1384 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1385 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1386 mock_update_block_device_mapping
.assert_not_called()
1388 @patch.object(vimconnector
, "update_block_device_mapping")
1389 def test_prepare_persistent_root_volumes_using_vim_id(
1390 self
, mock_update_block_device_mapping
1392 """Existing persistent root volume with vim_id."""
1393 vm_av_zone
= ["nova"]
1394 base_disk_index
= ord("a")
1395 disk
= {"vim_id": volume_id
}
1396 block_device_mapping
= {}
1397 existing_vim_volumes
= []
1399 expected_boot_vol_id
= None
1400 expected_block_device_mapping
= {"vda": volume_id
}
1401 expected_existing_vim_volumes
= [{"id": volume_id
}]
1402 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1407 block_device_mapping
,
1408 existing_vim_volumes
,
1411 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1412 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1413 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1414 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1415 mock_update_block_device_mapping
.assert_not_called()
1417 @patch.object(vimconnector
, "update_block_device_mapping")
1418 def test_prepare_persistent_non_root_volumes_using_vim_id(
1419 self
, mock_update_block_device_mapping
1421 """Existing persistent root volume with vim_id."""
1422 vm_av_zone
= ["nova"]
1423 base_disk_index
= ord("b")
1424 disk
= {"vim_id": volume_id
}
1425 block_device_mapping
= {}
1426 existing_vim_volumes
= []
1429 expected_block_device_mapping
= {"vdb": volume_id
}
1430 expected_existing_vim_volumes
= [{"id": volume_id
}]
1431 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1435 block_device_mapping
,
1437 existing_vim_volumes
,
1441 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1442 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1443 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1444 mock_update_block_device_mapping
.assert_not_called()
1446 @patch.object(vimconnector
, "update_block_device_mapping")
1447 def test_prepare_persistent_root_volumes_create(
1448 self
, mock_update_block_device_mapping
1450 """Create persistent root volume."""
1451 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1452 vm_av_zone
= ["nova"]
1453 base_disk_index
= ord("a")
1454 disk
= {"size": 10, "image_id": image_id
}
1455 block_device_mapping
= {}
1456 existing_vim_volumes
= []
1458 expected_boot_vol_id
= volume_id2
1459 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1464 block_device_mapping
,
1465 existing_vim_volumes
,
1468 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1469 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1473 availability_zone
=["nova"],
1475 mock_update_block_device_mapping
.assert_called_once()
1476 _call_mock_update_block_device_mapping
= (
1477 mock_update_block_device_mapping
.call_args_list
1480 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1481 block_device_mapping
,
1484 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1486 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1488 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1491 @patch.object(vimconnector
, "update_block_device_mapping")
1492 def test_prepare_persistent_root_volumes_create_with_keep(
1493 self
, mock_update_block_device_mapping
1495 """Create persistent root volume, disk has keep parameter."""
1496 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1497 vm_av_zone
= ["nova"]
1498 base_disk_index
= ord("a")
1499 disk
= {"size": 10, "image_id": image_id
, "keep": True}
1500 block_device_mapping
= {}
1501 existing_vim_volumes
= []
1503 expected_boot_vol_id
= volume_id2
1504 expected_existing_vim_volumes
= []
1505 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1510 block_device_mapping
,
1511 existing_vim_volumes
,
1514 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1515 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1516 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1520 availability_zone
=["nova"],
1522 mock_update_block_device_mapping
.assert_called_once()
1523 _call_mock_update_block_device_mapping
= (
1524 mock_update_block_device_mapping
.call_args_list
1527 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1528 block_device_mapping
,
1531 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1533 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1535 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1538 @patch.object(vimconnector
, "update_block_device_mapping")
1539 def test_prepare_persistent_non_root_volumes_create(
1540 self
, mock_update_block_device_mapping
1542 """Create persistent non-root volume."""
1543 self
.vimconn
.cinder
= CopyingMock()
1544 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1545 vm_av_zone
= ["nova"]
1546 base_disk_index
= ord("a")
1548 block_device_mapping
= {}
1549 existing_vim_volumes
= []
1551 expected_existing_vim_volumes
= []
1552 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1556 block_device_mapping
,
1558 existing_vim_volumes
,
1562 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1563 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1564 size
=10, name
="basicvmvda", availability_zone
=["nova"]
1566 mock_update_block_device_mapping
.assert_called_once()
1567 _call_mock_update_block_device_mapping
= (
1568 mock_update_block_device_mapping
.call_args_list
1571 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1572 block_device_mapping
,
1575 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1577 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1579 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1582 @patch.object(vimconnector
, "update_block_device_mapping")
1583 def test_prepare_persistent_non_root_volumes_create_with_keep(
1584 self
, mock_update_block_device_mapping
1586 """Create persistent non-root volume."""
1587 self
.vimconn
.cinder
= CopyingMock()
1588 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1589 vm_av_zone
= ["nova"]
1590 base_disk_index
= ord("a")
1591 disk
= {"size": 10, "keep": True}
1592 block_device_mapping
= {}
1593 existing_vim_volumes
= []
1595 expected_existing_vim_volumes
= []
1596 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1600 block_device_mapping
,
1602 existing_vim_volumes
,
1606 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1607 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1608 size
=10, name
="basicvmvda", availability_zone
=["nova"]
1610 mock_update_block_device_mapping
.assert_called_once()
1611 _call_mock_update_block_device_mapping
= (
1612 mock_update_block_device_mapping
.call_args_list
1615 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1616 block_device_mapping
,
1619 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1621 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1623 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1626 @patch.object(vimconnector
, "update_block_device_mapping")
1627 def test_new_shared_volumes(self
, mock_update_block_device_mapping
):
1628 """Create shared volume."""
1629 self
.vimconn
.cinder
= CopyingMock()
1630 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id4
1631 shared_volume_data
= {"size": 10, "name": "shared-volume"}
1632 self
.vimconn
.cinder
.volumes
.create
.side_effect
= [
1633 Volume("avaible", "multiattach", "shared-volume", volume_id4
)
1635 result
= self
.vimconn
.new_shared_volumes(shared_volume_data
)
1636 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1637 size
=10, name
="shared-volume", volume_type
="multiattach"
1639 self
.assertEqual(result
[0], "shared-volume")
1640 self
.assertEqual(result
[1], volume_id4
)
1642 @patch.object(vimconnector
, "update_block_device_mapping")
1643 def test_prepare_persistent_root_volumes_create_raise_exception(
1644 self
, mock_update_block_device_mapping
1646 """Create persistent root volume raise exception."""
1647 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
1648 vm_av_zone
= ["nova"]
1649 base_disk_index
= ord("a")
1650 disk
= {"size": 10, "image_id": image_id
}
1651 block_device_mapping
= {}
1652 existing_vim_volumes
= []
1655 with self
.assertRaises(Exception):
1656 result
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1661 block_device_mapping
,
1662 existing_vim_volumes
,
1666 self
.assertEqual(result
, None)
1668 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1672 availability_zone
=["nova"],
1674 self
.assertEqual(existing_vim_volumes
, [])
1675 self
.assertEqual(block_device_mapping
, {})
1676 self
.assertEqual(created_items
, {})
1677 mock_update_block_device_mapping
.assert_not_called()
1679 @patch.object(vimconnector
, "update_block_device_mapping")
1680 def test_prepare_persistent_non_root_volumes_create_raise_exception(
1681 self
, mock_update_block_device_mapping
1683 """Create persistent non-root volume raise exception."""
1684 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
1685 vm_av_zone
= ["nova"]
1686 base_disk_index
= ord("b")
1688 block_device_mapping
= {}
1689 existing_vim_volumes
= []
1692 with self
.assertRaises(Exception):
1693 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1697 block_device_mapping
,
1699 existing_vim_volumes
,
1703 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1704 size
=10, name
="basicvmvdb", availability_zone
=["nova"]
1706 self
.assertEqual(existing_vim_volumes
, [])
1707 self
.assertEqual(block_device_mapping
, {})
1708 self
.assertEqual(created_items
, {})
1709 mock_update_block_device_mapping
.assert_not_called()
1711 @patch("time.sleep")
1712 def test_wait_for_created_volumes_availability_volume_status_available(
1715 """Created volume status is available."""
1717 created_items
= {f
"volume:{volume_id2}": True}
1718 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1720 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1721 elapsed_time
, created_items
1723 self
.assertEqual(result
, elapsed_time
)
1724 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1725 mock_sleep
.assert_not_called()
1727 @patch("time.sleep")
1728 def test_wait_for_existing_volumes_availability_volume_status_available(
1731 """Existing volume status is available."""
1733 existing_vim_volumes
= [{"id": volume_id2
}]
1734 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1736 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1737 elapsed_time
, existing_vim_volumes
1739 self
.assertEqual(result
, elapsed_time
)
1740 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1741 mock_sleep
.assert_not_called()
1743 @patch("time.sleep")
1744 def test_wait_for_created_volumes_availability_status_processing_multiple_volumes(
1747 """Created volume status is processing."""
1750 f
"volume:{volume_id2}": True,
1751 f
"volume:{volume_id3}": True,
1753 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1754 Volume("processing"),
1755 Volume("available"),
1756 Volume("available"),
1759 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1760 elapsed_time
, created_items
1762 self
.assertEqual(result
, 10)
1763 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
1764 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
1765 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
1766 self
.assertEqual(_call_mock_get_volumes
[2][0], (volume_id3
,))
1767 mock_sleep
.assert_called_with(5)
1768 self
.assertEqual(1, mock_sleep
.call_count
)
1770 @patch("time.sleep")
1771 def test_wait_for_existing_volumes_availability_status_processing_multiple_volumes(
1774 """Existing volume status is processing."""
1776 existing_vim_volumes
= [
1778 {"id": "44e0e83-b9uu-4akk-t234-p9cc4811bd4a"},
1780 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1781 Volume("processing"),
1782 Volume("available", "multiattach"),
1783 Volume("available"),
1786 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1787 elapsed_time
, existing_vim_volumes
1789 self
.assertEqual(result
, 10)
1790 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
1791 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
1792 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
1794 _call_mock_get_volumes
[2][0], ("44e0e83-b9uu-4akk-t234-p9cc4811bd4a",)
1796 mock_sleep
.assert_called_with(5)
1797 self
.assertEqual(1, mock_sleep
.call_count
)
1799 @patch("time.sleep")
1800 def test_wait_for_created_volumes_availability_volume_status_processing_timeout(
1803 """Created volume status is processing, elapsed time greater than timeout (1800)."""
1805 created_items
= {f
"volume:{volume_id2}": True}
1806 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1807 Volume("processing"),
1808 Volume("processing"),
1810 with
patch("time.sleep", mock_sleep
):
1811 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1812 elapsed_time
, created_items
1814 self
.assertEqual(result
, 1805)
1815 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1816 mock_sleep
.assert_not_called()
1818 @patch("time.sleep")
1819 def test_wait_for_existing_volumes_availability_volume_status_processing_timeout(
1822 """Exsiting volume status is processing, elapsed time greater than timeout (1800)."""
1824 existing_vim_volumes
= [{"id": volume_id2
}]
1825 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1826 Volume("processing"),
1827 Volume("processing"),
1830 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1831 elapsed_time
, existing_vim_volumes
1833 self
.assertEqual(result
, 1805)
1834 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1835 mock_sleep
.assert_not_called()
1837 @patch("time.sleep")
1838 def test_wait_for_created_volumes_availability_cinder_raise_exception(
1841 """Cinder get volumes raises exception for created volumes."""
1843 created_items
= {f
"volume:{volume_id2}": True}
1844 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
1845 with self
.assertRaises(Exception):
1846 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1847 elapsed_time
, created_items
1849 self
.assertEqual(result
, 1000)
1850 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1851 mock_sleep
.assert_not_called()
1853 @patch("time.sleep")
1854 def test_wait_for_existing_volumes_availability_cinder_raise_exception(
1857 """Cinder get volumes raises exception for existing volumes."""
1859 existing_vim_volumes
= [{"id": volume_id2
}]
1860 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
1861 with self
.assertRaises(Exception):
1862 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1863 elapsed_time
, existing_vim_volumes
1865 self
.assertEqual(result
, 1000)
1866 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1867 mock_sleep
.assert_not_called()
1869 @patch("time.sleep")
1870 def test_wait_for_created_volumes_availability_no_volume_in_created_items(
1873 """Created_items dict does not have volume-id."""
1877 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
1879 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1880 elapsed_time
, created_items
1882 self
.assertEqual(result
, 10)
1883 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1884 mock_sleep
.assert_not_called()
1886 @patch("time.sleep")
1887 def test_wait_for_existing_volumes_availability_no_volume_in_existing_vim_volumes(
1890 """Existing_vim_volumes list does not have volume."""
1892 existing_vim_volumes
= []
1894 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
1896 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1897 elapsed_time
, existing_vim_volumes
1899 self
.assertEqual(result
, 10)
1900 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1901 mock_sleep
.assert_not_called()
1903 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
1904 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
1905 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
1906 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
1907 def test_prepare_disk_for_vm_instance(
1909 mock_existing_vol_availability
,
1910 mock_created_vol_availability
,
1911 mock_non_root_volumes
,
1914 """Prepare disks for VM instance successfully."""
1915 existing_vim_volumes
= []
1917 block_device_mapping
= {}
1918 vm_av_zone
= ["nova"]
1920 mock_root_volumes
.return_value
= root_vol_id
1921 mock_created_vol_availability
.return_value
= 10
1922 mock_existing_vol_availability
.return_value
= 15
1923 self
.vimconn
.cinder
= CopyingMock()
1924 self
.vimconn
._prepare
_disk
_for
_vminstance
(
1926 existing_vim_volumes
,
1929 block_device_mapping
,
1932 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_called_once_with(
1935 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
1936 mock_existing_vol_availability
.assert_called_once_with(10, existing_vim_volumes
)
1937 self
.assertEqual(mock_root_volumes
.call_count
, 1)
1938 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
1939 mock_root_volumes
.assert_called_once_with(
1941 vm_av_zone
=["nova"],
1942 disk
={"size": 10, "image_id": image_id
},
1944 block_device_mapping
={},
1945 existing_vim_volumes
=[],
1948 mock_non_root_volumes
.assert_called_once_with(
1951 vm_av_zone
=["nova"],
1953 block_device_mapping
={},
1954 existing_vim_volumes
=[],
1958 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
1959 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
1960 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
1961 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
1962 def test_prepare_disk_for_vm_instance_timeout_exceeded(
1964 mock_existing_vol_availability
,
1965 mock_created_vol_availability
,
1966 mock_non_root_volumes
,
1969 """Timeout exceeded while waiting for disks."""
1970 existing_vim_volumes
= []
1972 vm_av_zone
= ["nova"]
1973 block_device_mapping
= {}
1975 mock_root_volumes
.return_value
= root_vol_id
1976 mock_created_vol_availability
.return_value
= 1700
1977 mock_existing_vol_availability
.return_value
= 1900
1979 with self
.assertRaises(VimConnException
) as err
:
1980 self
.vimconn
._prepare
_disk
_for
_vminstance
(
1982 existing_vim_volumes
,
1985 block_device_mapping
,
1989 str(err
.exception
), "Timeout creating volumes for instance basicvm"
1991 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
1992 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
1993 mock_existing_vol_availability
.assert_called_once_with(
1994 1700, existing_vim_volumes
1996 self
.assertEqual(mock_root_volumes
.call_count
, 1)
1997 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
1998 mock_root_volumes
.assert_called_once_with(
2000 vm_av_zone
=["nova"],
2001 disk
={"size": 10, "image_id": image_id
},
2003 block_device_mapping
={},
2004 existing_vim_volumes
=[],
2007 mock_non_root_volumes
.assert_called_once_with(
2010 vm_av_zone
=["nova"],
2012 block_device_mapping
={},
2013 existing_vim_volumes
=[],
2017 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2018 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2019 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2020 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2021 def test_prepare_disk_for_vm_instance_empty_disk_list(
2023 mock_existing_vol_availability
,
2024 mock_created_vol_availability
,
2025 mock_non_root_volumes
,
2028 """Disk list is empty."""
2029 existing_vim_volumes
= []
2031 block_device_mapping
= {}
2032 vm_av_zone
= ["nova"]
2033 mock_created_vol_availability
.return_value
= 2
2034 mock_existing_vol_availability
.return_value
= 3
2036 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2038 existing_vim_volumes
,
2041 block_device_mapping
,
2044 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2045 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2046 mock_existing_vol_availability
.assert_called_once_with(2, existing_vim_volumes
)
2047 mock_root_volumes
.assert_not_called()
2048 mock_non_root_volumes
.assert_not_called()
2050 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2051 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2052 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2053 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2054 def test_prepare_disk_for_vm_instance_persistent_root_volume_error(
2056 mock_existing_vol_availability
,
2057 mock_created_vol_availability
,
2058 mock_non_root_volumes
,
2061 """Persistent root volumes preparation raises error."""
2062 existing_vim_volumes
= []
2064 vm_av_zone
= ["nova"]
2065 block_device_mapping
= {}
2067 mock_root_volumes
.side_effect
= Exception()
2068 mock_created_vol_availability
.return_value
= 10
2069 mock_existing_vol_availability
.return_value
= 15
2071 with self
.assertRaises(Exception):
2072 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2074 existing_vim_volumes
,
2077 block_device_mapping
,
2080 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2081 mock_created_vol_availability
.assert_not_called()
2082 mock_existing_vol_availability
.assert_not_called()
2083 mock_root_volumes
.assert_called_once_with(
2085 vm_av_zone
=["nova"],
2086 disk
={"size": 10, "image_id": image_id
},
2088 block_device_mapping
={},
2089 existing_vim_volumes
=[],
2092 mock_non_root_volumes
.assert_not_called()
2094 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2095 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2096 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2097 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2098 def test_prepare_disk_for_vm_instance_non_root_volume_error(
2100 mock_existing_vol_availability
,
2101 mock_created_vol_availability
,
2102 mock_non_root_volumes
,
2105 """Non-root volumes preparation raises error."""
2106 existing_vim_volumes
= []
2108 vm_av_zone
= ["nova"]
2109 block_device_mapping
= {}
2111 mock_root_volumes
.return_value
= root_vol_id
2112 mock_non_root_volumes
.side_effect
= Exception
2114 with self
.assertRaises(Exception):
2115 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2117 existing_vim_volumes
,
2120 block_device_mapping
,
2123 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2124 mock_created_vol_availability
.assert_not_called()
2125 mock_existing_vol_availability
.assert_not_called()
2126 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2127 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2128 mock_root_volumes
.assert_called_once_with(
2130 vm_av_zone
=["nova"],
2131 disk
={"size": 10, "image_id": image_id
},
2133 block_device_mapping
={},
2134 existing_vim_volumes
=[],
2137 mock_non_root_volumes
.assert_called_once_with(
2140 vm_av_zone
=["nova"],
2142 block_device_mapping
={},
2143 existing_vim_volumes
=[],
2147 def test_find_external_network_for_floating_ip_no_external_network(self
):
2148 """External network could not be found."""
2149 self
.vimconn
.neutron
.list_networks
.return_value
= {
2151 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": False}
2154 with self
.assertRaises(VimConnException
) as err
:
2155 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2158 "Cannot create floating_ip automatically since no external network is present",
2161 def test_find_external_network_for_floating_one_external_network(self
):
2162 """One external network has been found."""
2163 self
.vimconn
.neutron
.list_networks
.return_value
= {
2165 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True}
2168 expected_result
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
2169 result
= self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2170 self
.assertEqual(result
, expected_result
)
2172 def test_find_external_network_for_floating_neutron_raises_exception(self
):
2173 """Neutron list networks raises exception."""
2174 self
.vimconn
.neutron
.list_networks
.side_effect
= Exception
2175 with self
.assertRaises(Exception):
2176 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2178 def test_find_external_network_for_floating_several_external_network(self
):
2179 """Several exernal networks has been found."""
2180 self
.vimconn
.neutron
.list_networks
.return_value
= {
2182 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True},
2183 {"id": "608b73-y9cc-5a6a-a270-12cc4811bd4a", "router:external": True},
2186 with self
.assertRaises(VimConnException
) as err
:
2187 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2190 "Cannot create floating_ip automatically since multiple external networks are present",
2193 def test_neutron_create_float_ip(self
):
2194 """Floating ip creation is successful."""
2195 param
= {"net_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a"}
2197 self
.vimconn
.neutron
.create_floatingip
.return_value
= {
2198 "floatingip": {"id": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2200 expected_created_items
= {
2201 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True
2203 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2204 self
.assertEqual(created_items
, expected_created_items
)
2206 def test_neutron_create_float_ip_exception_occurred(self
):
2207 """Floating ip could not be created."""
2210 "floating_network_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a",
2211 "tenant_id": "308b73-19cc-8a6a-a270-02cc4811bd9a",
2215 self
.vimconn
.neutron
= CopyingMock()
2216 self
.vimconn
.neutron
.create_floatingip
.side_effect
= Exception(
2217 "Neutron floating ip create exception occurred."
2219 with self
.assertRaises(VimConnException
) as err
:
2220 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2221 self
.assertEqual(created_items
, {})
2224 "Exception: Cannot create new floating_ip Neutron floating ip create exception occurred.",
2227 @patch.object(vimconnector
, "_neutron_create_float_ip")
2228 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2229 def test_create_floating_ip_pool_id_available(
2230 self
, mock_find_ext_network
, mock_create_float_ip
2232 """Floating ip creation, ip pool is available."""
2233 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2237 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2238 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2241 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2242 mock_find_ext_network
.assert_not_called()
2243 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2245 @patch.object(vimconnector
, "_neutron_create_float_ip")
2246 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2247 def test_create_floating_ip_finding_pool_id(
2248 self
, mock_find_ext_network
, mock_create_float_ip
2250 """Floating ip creation, pool id need to be found."""
2251 floating_network
= {"floating_ip": True}
2253 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2256 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2257 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2260 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2261 mock_find_ext_network
.assert_called_once()
2262 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2264 @patch.object(vimconnector
, "_neutron_create_float_ip")
2265 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2266 def test_create_floating_ip_neutron_create_floating_ip_exception(
2267 self
, mock_find_ext_network
, mock_create_float_ip
2269 """Neutron creat floating ip raises error."""
2270 floating_network
= {"floating_ip": True}
2272 mock_create_float_ip
.side_effect
= VimConnException(
2273 "Can not create floating ip."
2275 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2278 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2279 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2283 with self
.assertRaises(VimConnException
) as err
:
2284 self
.vimconn
._create
_floating
_ip
(
2285 floating_network
, self
.server
, created_items
2287 self
.assertEqual(str(err
.exception
), "Can not create floating ip.")
2288 mock_find_ext_network
.assert_called_once()
2289 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2291 @patch.object(vimconnector
, "_neutron_create_float_ip")
2292 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2293 def test_create_floating_ip_can_not_find_pool_id(
2294 self
, mock_find_ext_network
, mock_create_float_ip
2296 """Floating ip creation, pool id could not be found."""
2297 floating_network
= {"floating_ip": True}
2299 mock_find_ext_network
.side_effect
= VimConnException(
2300 "Cannot create floating_ip automatically since no external network is present"
2302 with self
.assertRaises(VimConnException
) as err
:
2303 self
.vimconn
._create
_floating
_ip
(
2304 floating_network
, self
.server
, created_items
2308 "Cannot create floating_ip automatically since no external network is present",
2310 mock_find_ext_network
.assert_called_once()
2311 mock_create_float_ip
.assert_not_called()
2313 def test_find_floating_ip_get_free_floating_ip(self
):
2314 """Get free floating ips successfully."""
2317 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2318 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2319 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2322 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2323 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2325 result
= self
.vimconn
._find
_floating
_ip
(
2326 self
.server
, floating_ips
, floating_network
2328 self
.assertEqual(result
, expected_result
)
2330 def test_find_floating_ip_different_floating_network_id(self
):
2331 """Floating network id is different with floating_ip of floating network."""
2334 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2335 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2338 floating_network
= {"floating_ip": "508b73-t9cc-1a6a-a270-12cc4811bd4a"}
2340 result
= self
.vimconn
._find
_floating
_ip
(
2341 self
.server
, floating_ips
, floating_network
2343 self
.assertEqual(result
, None)
2345 def test_find_floating_ip_different_fip_tenant(self
):
2346 """Items in floating_ips has port_id, tenant_is is not same with server tenant id."""
2349 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2350 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2351 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2352 "tenant_id": self
.server
.id,
2355 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2356 mock_create_floating_ip
= CopyingMock()
2357 with patch
.object(vimconnector
, "_create_floating_ip", mock_create_floating_ip
):
2358 result
= self
.vimconn
._find
_floating
_ip
(
2359 self
.server
, floating_ips
, floating_network
2361 self
.assertEqual(result
, None)
2363 @patch("time.sleep")
2364 def test_assign_floating_ip(self
, mock_sleep
):
2365 """Assign floating ip successfully."""
2366 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2367 floating_network
= {"vim_id": floating_network_vim_id
}
2369 "port_id": floating_network_vim_id
,
2370 "floating_network_id": "p08b73-e9cc-5a6a-t270-82cc4811bd4a",
2371 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2372 "tenant_id": "k08b73-e9cc-5a6a-t270-82cc4811bd4a",
2374 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
2375 self
.vimconn
.neutron
.show_floatingip
.return_value
= fip
2376 expected_result
= fip
2378 result
= self
.vimconn
._assign
_floating
_ip
(free_floating_ip
, floating_network
)
2379 self
.assertEqual(result
, expected_result
)
2380 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2382 {"floatingip": {"port_id": floating_network_vim_id
}},
2384 mock_sleep
.assert_called_once_with(5)
2385 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
2387 @patch("time.sleep")
2388 def test_assign_floating_ip_update_floating_ip_exception(self
, mock_sleep
):
2389 """Neutron update floating ip raises exception."""
2390 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2391 floating_network
= {"vim_id": floating_network_vim_id
}
2392 self
.vimconn
.neutron
= CopyingMock()
2393 self
.vimconn
.neutron
.update_floatingip
.side_effect
= Exception(
2394 "Floating ip is not updated."
2397 with self
.assertRaises(Exception) as err
:
2398 result
= self
.vimconn
._assign
_floating
_ip
(
2399 free_floating_ip
, floating_network
2401 self
.assertEqual(result
, None)
2402 self
.assertEqual(str(err
.exception
), "Floating ip is not updated.")
2404 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2406 {"floatingip": {"port_id": floating_network_vim_id
}},
2408 mock_sleep
.assert_not_called()
2409 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2411 @patch("time.sleep")
2412 def test_assign_floating_ip_show_floating_ip_exception(self
, mock_sleep
):
2413 """Neutron show floating ip raises exception."""
2414 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2415 floating_network
= {"vim_id": floating_network_vim_id
}
2416 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
2417 self
.vimconn
.neutron
.show_floatingip
.side_effect
= Exception(
2418 "Floating ip could not be shown."
2421 with self
.assertRaises(Exception) as err
:
2422 result
= self
.vimconn
._assign
_floating
_ip
(
2423 free_floating_ip
, floating_network
2425 self
.assertEqual(result
, None)
2426 self
.assertEqual(str(err
.exception
), "Floating ip could not be shown.")
2427 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2429 {"floatingip": {"port_id": floating_network_vim_id
}},
2431 mock_sleep
.assert_called_once_with(5)
2432 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
2434 @patch("random.shuffle")
2435 @patch.object(vimconnector
, "_find_floating_ip")
2436 def test_get_free_floating_ip(self
, mock_find_floating_ip
, mock_shuffle
):
2437 """Get free floating ip successfully."""
2438 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2441 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2442 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2443 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2444 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2447 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
2448 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2449 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
2450 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2453 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
2454 "floatingips": floating_ips
2456 mock_find_floating_ip
.return_value
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2457 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2459 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2460 self
.assertEqual(result
, expected_result
)
2461 mock_shuffle
.assert_called_once_with(floating_ips
)
2462 mock_find_floating_ip
.assert_called_once_with(
2463 self
.server
, floating_ips
, floating_network
2466 @patch("random.shuffle")
2467 @patch.object(vimconnector
, "_find_floating_ip")
2468 def test_get_free_floating_ip_list_floating_ip_exception(
2469 self
, mock_find_floating_ip
, mock_shuffle
2471 """Neutron list floating IPs raises exception."""
2472 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2473 self
.vimconn
.neutron
= CopyingMock()
2474 self
.vimconn
.neutron
.list_floatingips
.side_effect
= Exception(
2475 "Floating ips could not be listed."
2477 with self
.assertRaises(Exception) as err
:
2478 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2479 self
.assertEqual(result
, None)
2480 self
.assertEqual(str(err
.exception
), "Floating ips could not be listed.")
2481 mock_shuffle
.assert_not_called()
2482 mock_find_floating_ip
.assert_not_called()
2484 @patch("random.shuffle")
2485 @patch.object(vimconnector
, "_find_floating_ip")
2486 def test_get_free_floating_ip_find_floating_ip_exception(
2487 self
, mock_find_floating_ip
, mock_shuffle
2489 """_find_floating_ip method raises exception."""
2490 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2493 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2494 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2495 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2496 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2499 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
2500 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2501 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
2502 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2505 self
.vimconn
.neutron
= CopyingMock()
2506 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
2507 "floatingips": floating_ips
2509 mock_find_floating_ip
.side_effect
= Exception(
2510 "Free floating ip could not be found."
2513 with self
.assertRaises(Exception) as err
:
2514 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2515 self
.assertEqual(result
, None)
2516 self
.assertEqual(str(err
.exception
), "Free floating ip could not be found.")
2517 mock_shuffle
.assert_called_once_with(floating_ips
)
2518 mock_find_floating_ip
.assert_called_once_with(
2519 self
.server
, floating_ips
, floating_network
2522 @patch.object(vimconnector
, "_create_floating_ip")
2523 @patch.object(vimconnector
, "_get_free_floating_ip")
2524 @patch.object(vimconnector
, "_assign_floating_ip")
2525 def test_prepare_external_network_for_vm_instance(
2527 mock_assign_floating_ip
,
2528 mock_get_free_floating_ip
,
2529 mock_create_floating_ip
,
2531 """Prepare external network successfully."""
2532 external_network
= [
2534 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2535 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2539 vm_start_time
= time_return_value
2540 mock_get_free_floating_ip
.side_effect
= ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
2541 mock_assign_floating_ip
.return_value
= {
2542 "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
2544 self
.vimconn
.neutron
= CopyingMock()
2545 self
.vimconn
.nova
= CopyingMock()
2546 self
.vimconn
.neutron
.show_floatingip
.return_value
= {
2547 "floatingip": {"port_id": ""}
2550 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2551 external_network
, self
.server
, created_items
, vm_start_time
2554 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2555 mock_get_free_floating_ip
.assert_called_once_with(
2558 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2559 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2562 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(
2563 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
2565 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2566 mock_create_floating_ip
.assert_not_called()
2567 mock_assign_floating_ip
.assert_called_once_with(
2568 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2570 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2571 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2576 @patch("time.sleep")
2577 @patch.object(vimconnector
, "_create_floating_ip")
2578 @patch.object(vimconnector
, "_get_free_floating_ip")
2579 @patch.object(vimconnector
, "_assign_floating_ip")
2580 def test_prepare_external_network_for_vm_instance_no_free_floating_ip(
2582 mock_assign_floating_ip
,
2583 mock_get_free_floating_ip
,
2584 mock_create_floating_ip
,
2588 """There is not any free floating ip."""
2589 floating_network
= {
2590 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2591 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2593 external_network
= [floating_network
]
2596 vm_start_time
= time_return_value
2597 mock_get_free_floating_ip
.return_value
= None
2598 mock_assign_floating_ip
.return_value
= {}
2599 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2600 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2602 with self
.assertRaises(KeyError):
2603 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2604 external_network
, self
.server
, created_items
, vm_start_time
2607 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2608 mock_get_free_floating_ip
.assert_called_with(
2611 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2612 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2615 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(None)
2616 mock_sleep
.assert_not_called()
2617 mock_time
.assert_not_called()
2618 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
2619 mock_create_floating_ip
.assert_called_with(
2620 floating_network
, self
.server
, created_items
2622 self
.assertEqual(mock_create_floating_ip
.call_count
, 4)
2623 mock_assign_floating_ip
.assert_not_called()
2624 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2627 @patch("time.sleep")
2628 @patch.object(vimconnector
, "_create_floating_ip")
2629 @patch.object(vimconnector
, "_get_free_floating_ip")
2630 @patch.object(vimconnector
, "_assign_floating_ip")
2631 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
2633 mock_assign_floating_ip
,
2634 mock_get_free_floating_ip
,
2635 mock_create_floating_ip
,
2639 """There is not any free floating ip, create_floating ip method raise exception
2640 exit_on_floating_ip_error set to False."""
2641 floating_network
= {
2642 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2643 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2644 "exit_on_floating_ip_error": False,
2646 external_network
= [floating_network
]
2649 vm_start_time
= time_return_value
2650 mock_get_free_floating_ip
.return_value
= None
2651 mock_assign_floating_ip
.return_value
= {}
2652 mock_create_floating_ip
.side_effect
= VimConnException(
2653 "Can not create floating ip."
2655 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2656 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2658 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2659 external_network
, self
.server
, created_items
, vm_start_time
2661 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2662 mock_get_free_floating_ip
.assert_called_with(
2665 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2666 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2667 "exit_on_floating_ip_error": False,
2670 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2671 mock_sleep
.assert_not_called()
2672 mock_time
.assert_not_called()
2673 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2674 mock_create_floating_ip
.assert_called_with(
2675 floating_network
, self
.server
, created_items
2677 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
2678 mock_assign_floating_ip
.assert_not_called()
2681 @patch("time.sleep")
2682 @patch.object(vimconnector
, "_create_floating_ip")
2683 @patch.object(vimconnector
, "_get_free_floating_ip")
2684 @patch.object(vimconnector
, "_assign_floating_ip")
2685 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
2687 mock_assign_floating_ip
,
2688 mock_get_free_floating_ip
,
2689 mock_create_floating_ip
,
2693 """There is not any free floating ip, create_floating ip method raise exception
2694 exit_on_floating_ip_error set to False."""
2695 floating_network
= {
2696 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2697 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2698 "exit_on_floating_ip_error": True,
2700 external_network
= [floating_network
]
2703 vm_start_time
= time_return_value
2704 mock_get_free_floating_ip
.return_value
= None
2705 mock_assign_floating_ip
.return_value
= {}
2706 mock_create_floating_ip
.side_effect
= VimConnException(
2707 "Can not create floating ip."
2709 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2710 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2711 with self
.assertRaises(VimConnException
):
2712 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2713 external_network
, self
.server
, created_items
, vm_start_time
2715 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2716 mock_get_free_floating_ip
.assert_called_with(
2719 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2720 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2721 "exit_on_floating_ip_error": True,
2724 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2725 mock_sleep
.assert_not_called()
2726 mock_time
.assert_not_called()
2727 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2728 mock_create_floating_ip
.assert_called_with(
2729 floating_network
, self
.server
, created_items
2731 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
2732 mock_assign_floating_ip
.assert_not_called()
2734 @patch.object(vimconnector
, "_create_floating_ip")
2735 @patch.object(vimconnector
, "_get_free_floating_ip")
2736 @patch.object(vimconnector
, "_assign_floating_ip")
2737 def test_prepare_external_network_for_vm_instance_fip_has_port_id(
2739 mock_assign_floating_ip
,
2740 mock_get_free_floating_ip
,
2741 mock_create_floating_ip
,
2743 """Neutron show floating ip return the fip with port_id and floating network vim_id
2744 is different from port_id."""
2745 floating_network
= {
2746 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2747 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2749 external_network
= [floating_network
]
2752 mock_get_free_floating_ip
.side_effect
= [
2753 "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
2754 "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
2755 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2757 mock_assign_floating_ip
.side_effect
= [
2758 {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2759 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2761 self
.vimconn
.neutron
= CopyingMock()
2762 self
.vimconn
.nova
= CopyingMock()
2763 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2764 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2765 {"floatingip": {"port_id": ""}},
2766 {"floatingip": {"port_id": ""}},
2768 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2769 external_network
, self
.server
, created_items
, vm_start_time
2771 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
2772 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2774 _call_mock_get_free_floating_ip
[0][0],
2781 _call_mock_get_free_floating_ip
[1][0],
2788 _call_mock_get_free_floating_ip
[2][0],
2794 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
2795 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2796 mock_create_floating_ip
.assert_not_called()
2797 self
.assertEqual(mock_assign_floating_ip
.call_count
, 2)
2798 _call_mock_assign_floating_ip
= mock_assign_floating_ip
.call_args_list
2800 _call_mock_assign_floating_ip
[0][0],
2801 ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
2804 _call_mock_assign_floating_ip
[1][0],
2805 ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
2809 @patch("time.sleep")
2810 @patch.object(vimconnector
, "_create_floating_ip")
2811 @patch.object(vimconnector
, "_get_free_floating_ip")
2812 @patch.object(vimconnector
, "_assign_floating_ip")
2813 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
2815 mock_assign_floating_ip
,
2816 mock_get_free_floating_ip
,
2817 mock_create_floating_ip
,
2821 """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
2822 VM status is in error."""
2823 floating_network
= {
2824 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2825 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2826 "exit_on_floating_ip_error": True,
2828 external_network
= [floating_network
]
2830 vm_start_time
= time_return_value
2832 mock_time
.side_effect
= [156570150, 156570800, 156571200]
2834 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2835 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2836 Exception("Floating ip could not be shown.")
2838 with self
.assertRaises(Exception) as err
:
2839 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2840 external_network
, self
.server
, created_items
, vm_start_time
2844 "Cannot create floating_ip: Exception Floating ip could not be shown.",
2847 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2848 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2850 _call_mock_get_free_floating_ip
[0][0],
2857 _call_mock_get_free_floating_ip
[1][0],
2864 _call_mock_get_free_floating_ip
[2][0],
2871 _call_mock_get_free_floating_ip
[3][0],
2878 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
2879 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2880 mock_create_floating_ip
.assert_not_called()
2881 mock_assign_floating_ip
.assert_not_called()
2882 mock_time
.assert_not_called()
2883 mock_sleep
.assert_not_called()
2886 @patch("time.sleep")
2887 @patch.object(vimconnector
, "_create_floating_ip")
2888 @patch.object(vimconnector
, "_get_free_floating_ip")
2889 @patch.object(vimconnector
, "_assign_floating_ip")
2890 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
2892 mock_assign_floating_ip
,
2893 mock_get_free_floating_ip
,
2894 mock_create_floating_ip
,
2898 """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
2899 VM status is in active."""
2900 floating_network
= {
2901 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2902 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2903 "exit_on_floating_ip_error": False,
2905 external_network
= [floating_network
]
2907 vm_start_time
= time_return_value
2909 mock_time
.side_effect
= [156570150, 156570800, 156571200]
2911 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ACTIVE"
2912 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2913 Exception("Floating ip could not be shown.")
2916 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2917 external_network
, self
.server
, created_items
, vm_start_time
2919 # self.assertEqual(str(err.exception), "Cannot create floating_ip")
2921 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2922 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2924 _call_mock_get_free_floating_ip
[0][0],
2931 _call_mock_get_free_floating_ip
[1][0],
2938 _call_mock_get_free_floating_ip
[2][0],
2945 _call_mock_get_free_floating_ip
[3][0],
2952 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
2953 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2954 mock_create_floating_ip
.assert_not_called()
2955 mock_assign_floating_ip
.assert_not_called()
2956 mock_time
.assert_not_called()
2957 mock_sleep
.assert_not_called()
2960 @patch("time.sleep")
2961 @patch.object(vimconnector
, "_create_floating_ip")
2962 @patch.object(vimconnector
, "_get_free_floating_ip")
2963 @patch.object(vimconnector
, "_assign_floating_ip")
2964 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
2966 mock_assign_floating_ip
,
2967 mock_get_free_floating_ip
,
2968 mock_create_floating_ip
,
2972 """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
2973 VM status is not ACTIVE or ERROR, server timeout happened."""
2974 floating_network
= {
2975 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2976 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2977 "exit_on_floating_ip_error": True,
2979 external_network
= [floating_network
]
2981 vm_start_time
= time_return_value
2982 mock_get_free_floating_ip
.side_effect
= None
2983 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
2984 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "OTHER"
2985 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2986 Exception("Floating ip could not be shown.")
2989 with self
.assertRaises(VimConnException
) as err
:
2990 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2991 external_network
, self
.server
, created_items
, vm_start_time
2995 "Cannot create floating_ip: Exception Floating ip could not be shown.",
2998 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
2999 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3001 _call_mock_get_free_floating_ip
[0][0],
3008 _call_mock_get_free_floating_ip
[1][0],
3015 _call_mock_get_free_floating_ip
[2][0],
3022 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3023 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3024 mock_create_floating_ip
.assert_not_called()
3025 mock_assign_floating_ip
.assert_not_called()
3026 self
.assertEqual(mock_time
.call_count
, 3)
3027 self
.assertEqual(mock_sleep
.call_count
, 2)
3030 @patch("time.sleep")
3031 @patch.object(vimconnector
, "_create_floating_ip")
3032 @patch.object(vimconnector
, "_get_free_floating_ip")
3033 @patch.object(vimconnector
, "_assign_floating_ip")
3034 def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3036 mock_assign_floating_ip
,
3037 mock_get_free_floating_ip
,
3038 mock_create_floating_ip
,
3042 """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3043 VM status is in ERROR."""
3044 floating_network
= {
3045 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3046 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3047 "exit_on_floating_ip_error": True,
3049 external_network
= [floating_network
]
3051 vm_start_time
= time_return_value
3053 mock_get_free_floating_ip
.side_effect
= [
3054 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3057 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3059 mock_assign_floating_ip
.side_effect
= [
3060 Exception("Floating ip could not be assigned.")
3063 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3064 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3065 {"floatingip": {"port_id": ""}}
3068 with self
.assertRaises(VimConnException
) as err
:
3069 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3070 external_network
, self
.server
, created_items
, vm_start_time
3074 "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3077 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3078 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3080 _call_mock_get_free_floating_ip
[0][0],
3087 _call_mock_get_free_floating_ip
[1][0],
3094 _call_mock_get_free_floating_ip
[2][0],
3101 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3102 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(
3103 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3105 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3106 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3107 mock_time
.assert_not_called()
3108 mock_sleep
.assert_not_called()
3109 mock_create_floating_ip
.assert_not_called()
3112 @patch("time.sleep")
3113 @patch.object(vimconnector
, "_create_floating_ip")
3114 @patch.object(vimconnector
, "_get_free_floating_ip")
3115 @patch.object(vimconnector
, "_assign_floating_ip")
3116 def test_prepare_external_network_for_vm_instance_empty_external_network_list(
3118 mock_assign_floating_ip
,
3119 mock_get_free_floating_ip
,
3120 mock_create_floating_ip
,
3124 """External network list is empty."""
3125 external_network
= []
3127 vm_start_time
= time_return_value
3129 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3130 external_network
, self
.server
, created_items
, vm_start_time
3132 mock_create_floating_ip
.assert_not_called()
3133 mock_time
.assert_not_called()
3134 mock_sleep
.assert_not_called()
3135 mock_assign_floating_ip
.assert_not_called()
3136 mock_get_free_floating_ip
.assert_not_called()
3137 self
.vimconn
.neutron
.show
.show_floatingip
.assert_not_called()
3138 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3140 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3141 def test_update_port_security_for_vm_instance(self
, mock_wait_for_vm
):
3142 """no_secured_ports has port and the port has allow-address-pairs."""
3143 no_secured_ports
= [(port2_id
, "allow-address-pairs")]
3145 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3147 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3149 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3151 {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
3154 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3155 def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
3156 self
, mock_wait_for_vm
3158 """no_secured_ports has port and the port does not have allow-address-pairs."""
3159 no_secured_ports
= [(port2_id
, "something")]
3161 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3163 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3165 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3167 {"port": {"port_security_enabled": False, "security_groups": None}},
3170 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3171 def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
3172 self
, mock_wait_for_vm
3174 """__wait_for_vm raises timeout exception."""
3175 no_secured_ports
= [(port2_id
, "something")]
3177 mock_wait_for_vm
.side_effect
= VimConnException("Timeout waiting for instance.")
3179 with self
.assertRaises(VimConnException
) as err
:
3180 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3181 no_secured_ports
, self
.server
3183 self
.assertEqual(str(err
.exception
), "Timeout waiting for instance.")
3185 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3187 self
.vimconn
.neutron
.update_port
.assert_not_called()
3189 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3190 def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
3191 self
, mock_wait_for_vm
3193 """neutron_update_port method raises exception."""
3194 no_secured_ports
= [(port2_id
, "something")]
3196 self
.vimconn
.neutron
.update_port
.side_effect
= Exception(
3197 "Port security could not be updated."
3200 with self
.assertRaises(VimConnException
) as err
:
3201 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3202 no_secured_ports
, self
.server
3206 "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
3208 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3210 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3212 {"port": {"port_security_enabled": False, "security_groups": None}},
3215 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3216 def test_update_port_security_for_vm_instance_empty_port_list(
3217 self
, mock_wait_for_vm
3219 """no_secured_ports list does not have any ports."""
3220 no_secured_ports
= []
3222 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3224 mock_wait_for_vm
.assert_not_called()
3226 self
.vimconn
.neutron
.update_port
.assert_not_called()
3229 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3230 @patch.object(vimconnector
, "_reload_connection")
3231 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3232 @patch.object(vimconnector
, "_create_user_data")
3233 @patch.object(vimconnector
, "_get_vm_availability_zone")
3234 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3235 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3236 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3237 @patch.object(vimconnector
, "delete_vminstance")
3238 @patch.object(vimconnector
, "_format_exception")
3239 def test_new_vm_instance(
3241 mock_format_exception
,
3242 mock_delete_vm_instance
,
3243 mock_prepare_external_network
,
3244 mock_update_port_security
,
3245 mock_prepare_disk_for_vm_instance
,
3246 mock_get_vm_availability_zone
,
3247 mock_create_user_data
,
3248 mock_prepare_network_for_vm_instance
,
3249 mock_reload_connection
,
3250 mock_remove_keep_flag_from_persistent_volumes
,
3253 """New VM instance creation is successful."""
3255 mock_create_user_data
.return_value
= True, "userdata"
3257 mock_get_vm_availability_zone
.return_value
= "nova"
3259 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3261 mock_time
.return_value
= time_return_value
3263 expected_result
= self
.server
.id, {}
3265 result
= self
.vimconn
.new_vminstance(
3271 affinity_group_list
,
3275 availability_zone_index
,
3276 availability_zone_list
,
3278 self
.assertEqual(result
, expected_result
)
3280 mock_reload_connection
.assert_called_once()
3281 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3286 external_network
=[],
3287 no_secured_ports
=[],
3289 mock_create_user_data
.assert_called_once_with(cloud_config
)
3290 mock_get_vm_availability_zone
.assert_called_once_with(
3291 availability_zone_index
, availability_zone_list
3293 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3295 existing_vim_volumes
=[],
3298 block_device_mapping
={},
3299 disk_list
=disk_list2
,
3301 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3306 security_groups
="default",
3307 availability_zone
="nova",
3308 key_name
="my_keypair",
3309 userdata
="userdata",
3311 block_device_mapping
={},
3314 mock_time
.assert_called_once()
3315 mock_update_port_security
.assert_called_once_with([], self
.server
)
3316 mock_prepare_external_network
.assert_called_once_with(
3317 external_network
=[],
3320 vm_start_time
=time_return_value
,
3322 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
3323 mock_delete_vm_instance
.assert_not_called()
3324 mock_format_exception
.assert_not_called()
3327 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3328 @patch.object(vimconnector
, "_reload_connection")
3329 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3330 @patch.object(vimconnector
, "_create_user_data")
3331 @patch.object(vimconnector
, "_get_vm_availability_zone")
3332 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3333 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3334 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3335 @patch.object(vimconnector
, "delete_vminstance")
3336 @patch.object(vimconnector
, "_format_exception")
3337 def test_new_vm_instance_create_user_data_fails(
3339 mock_format_exception
,
3340 mock_delete_vm_instance
,
3341 mock_prepare_external_network
,
3342 mock_update_port_security
,
3343 mock_prepare_disk_for_vm_instance
,
3344 mock_get_vm_availability_zone
,
3345 mock_create_user_data
,
3346 mock_prepare_network_for_vm_instance
,
3347 mock_reload_connection
,
3348 mock_remove_keep_flag_from_persistent_volumes
,
3351 """New VM instance creation failed because of user data creation failure."""
3353 mock_create_user_data
.side_effect
= Exception(
3354 "User data could not be retrieved."
3357 mock_get_vm_availability_zone
.return_value
= "nova"
3359 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3361 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3363 mock_time
.return_value
= time_return_value
3365 self
.vimconn
.new_vminstance(
3371 affinity_group_list
,
3375 availability_zone_index
,
3376 availability_zone_list
,
3379 mock_reload_connection
.assert_called_once()
3380 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3385 external_network
=[],
3386 no_secured_ports
=[],
3388 mock_create_user_data
.assert_called_once_with(cloud_config
)
3389 mock_get_vm_availability_zone
.assert_not_called()
3390 mock_prepare_disk_for_vm_instance
.assert_not_called()
3391 self
.vimconn
.nova
.servers
.create
.assert_not_called()
3392 mock_time
.assert_not_called()
3393 mock_update_port_security
.assert_not_called()
3394 mock_prepare_external_network
.assert_not_called()
3395 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3396 mock_delete_vm_instance
.assert_called_once_with(None, {})
3397 mock_format_exception
.assert_called_once()
3398 arg
= mock_format_exception
.call_args
[0][0]
3399 self
.assertEqual(str(arg
), "User data could not be retrieved.")
3402 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3403 @patch.object(vimconnector
, "_reload_connection")
3404 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3405 @patch.object(vimconnector
, "_create_user_data")
3406 @patch.object(vimconnector
, "_get_vm_availability_zone")
3407 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3408 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3409 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3410 @patch.object(vimconnector
, "delete_vminstance")
3411 @patch.object(vimconnector
, "_format_exception")
3412 def test_new_vm_instance_external_network_exception(
3414 mock_format_exception
,
3415 mock_delete_vm_instance
,
3416 mock_prepare_external_network
,
3417 mock_update_port_security
,
3418 mock_prepare_disk_for_vm_instance
,
3419 mock_get_vm_availability_zone
,
3420 mock_create_user_data
,
3421 mock_prepare_network_for_vm_instance
,
3422 mock_reload_connection
,
3423 mock_remove_keep_flag_from_persistent_volumes
,
3426 """New VM instance creation, external network connection has failed as floating
3427 ip could not be created."""
3429 mock_create_user_data
.return_value
= True, "userdata"
3431 mock_get_vm_availability_zone
.return_value
= "nova"
3433 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3435 mock_time
.return_value
= time_return_value
3437 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3439 mock_prepare_external_network
.side_effect
= VimConnException(
3440 "Can not create floating ip."
3443 self
.vimconn
.new_vminstance(
3449 affinity_group_list
,
3453 availability_zone_index
,
3454 availability_zone_list
,
3457 mock_reload_connection
.assert_called_once()
3458 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3463 external_network
=[],
3464 no_secured_ports
=[],
3466 mock_create_user_data
.assert_called_once_with(cloud_config
)
3467 mock_get_vm_availability_zone
.assert_called_once_with(
3468 availability_zone_index
, availability_zone_list
3470 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3472 existing_vim_volumes
=[],
3475 block_device_mapping
={},
3476 disk_list
=disk_list2
,
3478 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3483 security_groups
="default",
3484 availability_zone
="nova",
3485 key_name
="my_keypair",
3486 userdata
="userdata",
3488 block_device_mapping
={},
3491 mock_time
.assert_called_once()
3492 mock_update_port_security
.assert_called_once_with([], self
.server
)
3493 mock_prepare_external_network
.assert_called_once_with(
3494 external_network
=[],
3497 vm_start_time
=time_return_value
,
3499 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3500 mock_delete_vm_instance
.assert_called_once_with(self
.server
.id, {})
3501 mock_format_exception
.assert_called_once()
3502 arg
= mock_format_exception
.call_args
[0][0]
3503 self
.assertEqual(str(arg
), "Can not create floating ip.")
3506 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3507 @patch.object(vimconnector
, "_reload_connection")
3508 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3509 @patch.object(vimconnector
, "_create_user_data")
3510 @patch.object(vimconnector
, "_get_vm_availability_zone")
3511 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3512 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3513 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3514 @patch.object(vimconnector
, "delete_vminstance")
3515 @patch.object(vimconnector
, "_format_exception")
3516 def test_new_vm_instance_with_affinity_group(
3518 mock_format_exception
,
3519 mock_delete_vm_instance
,
3520 mock_prepare_external_network
,
3521 mock_update_port_security
,
3522 mock_prepare_disk_for_vm_instance
,
3523 mock_get_vm_availability_zone
,
3524 mock_create_user_data
,
3525 mock_prepare_network_for_vm_instance
,
3526 mock_reload_connection
,
3527 mock_remove_keep_flag_from_persistent_volumes
,
3530 """New VM creation with affinity group."""
3531 affinity_group_list
= [
3532 {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
3534 mock_create_user_data
.return_value
= True, "userdata"
3535 mock_get_vm_availability_zone
.return_value
= "nova"
3536 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3537 mock_time
.return_value
= time_return_value
3538 expected_result
= self
.server
.id, {}
3540 result
= self
.vimconn
.new_vminstance(
3546 affinity_group_list
,
3550 availability_zone_index
,
3551 availability_zone_list
,
3553 self
.assertEqual(result
, expected_result
)
3555 mock_reload_connection
.assert_called_once()
3556 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3561 external_network
=[],
3562 no_secured_ports
=[],
3564 mock_create_user_data
.assert_called_once_with(cloud_config
)
3565 mock_get_vm_availability_zone
.assert_called_once_with(
3566 availability_zone_index
, availability_zone_list
3568 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3570 existing_vim_volumes
=[],
3573 block_device_mapping
={},
3574 disk_list
=disk_list2
,
3576 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3581 security_groups
="default",
3582 availability_zone
="nova",
3583 key_name
="my_keypair",
3584 userdata
="userdata",
3586 block_device_mapping
={},
3587 scheduler_hints
={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
3589 mock_time
.assert_called_once()
3590 mock_update_port_security
.assert_called_once_with([], self
.server
)
3591 mock_prepare_external_network
.assert_called_once_with(
3592 external_network
=[],
3595 vm_start_time
=time_return_value
,
3597 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
3598 mock_delete_vm_instance
.assert_not_called()
3599 mock_format_exception
.assert_not_called()
3602 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3603 @patch.object(vimconnector
, "_reload_connection")
3604 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3605 @patch.object(vimconnector
, "_create_user_data")
3606 @patch.object(vimconnector
, "_get_vm_availability_zone")
3607 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3608 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3609 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3610 @patch.object(vimconnector
, "delete_vminstance")
3611 @patch.object(vimconnector
, "_format_exception")
3612 def test_new_vm_instance_nova_server_create_failed(
3614 mock_format_exception
,
3615 mock_delete_vm_instance
,
3616 mock_prepare_external_network
,
3617 mock_update_port_security
,
3618 mock_prepare_disk_for_vm_instance
,
3619 mock_get_vm_availability_zone
,
3620 mock_create_user_data
,
3621 mock_prepare_network_for_vm_instance
,
3622 mock_reload_connection
,
3623 mock_remove_keep_flag_from_persistent_volumes
,
3626 """New VM(server) creation failed."""
3628 mock_create_user_data
.return_value
= True, "userdata"
3630 mock_get_vm_availability_zone
.return_value
= "nova"
3632 self
.vimconn
.nova
.servers
.create
.side_effect
= Exception(
3633 "Server could not be created."
3636 mock_time
.return_value
= time_return_value
3638 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3640 self
.vimconn
.new_vminstance(
3646 affinity_group_list
,
3650 availability_zone_index
,
3651 availability_zone_list
,
3654 mock_reload_connection
.assert_called_once()
3655 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3660 external_network
=[],
3661 no_secured_ports
=[],
3663 mock_create_user_data
.assert_called_once_with(cloud_config
)
3664 mock_get_vm_availability_zone
.assert_called_once_with(
3665 availability_zone_index
, availability_zone_list
3667 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3669 existing_vim_volumes
=[],
3672 block_device_mapping
={},
3673 disk_list
=disk_list2
,
3676 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3681 security_groups
="default",
3682 availability_zone
="nova",
3683 key_name
="my_keypair",
3684 userdata
="userdata",
3686 block_device_mapping
={},
3689 mock_time
.assert_not_called()
3690 mock_update_port_security
.assert_not_called()
3691 mock_prepare_external_network
.assert_not_called()
3692 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3693 mock_delete_vm_instance
.assert_called_once_with(None, {})
3694 mock_format_exception
.assert_called_once()
3695 arg
= mock_format_exception
.call_args
[0][0]
3696 self
.assertEqual(str(arg
), "Server could not be created.")
3699 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3700 @patch.object(vimconnector
, "_reload_connection")
3701 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3702 @patch.object(vimconnector
, "_create_user_data")
3703 @patch.object(vimconnector
, "_get_vm_availability_zone")
3704 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3705 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3706 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3707 @patch.object(vimconnector
, "delete_vminstance")
3708 @patch.object(vimconnector
, "_format_exception")
3709 def test_new_vm_instance_connection_exception(
3711 mock_format_exception
,
3712 mock_delete_vm_instance
,
3713 mock_prepare_external_network
,
3714 mock_update_port_security
,
3715 mock_prepare_disk_for_vm_instance
,
3716 mock_get_vm_availability_zone
,
3717 mock_create_user_data
,
3718 mock_prepare_network_for_vm_instance
,
3719 mock_reload_connection
,
3720 mock_remove_keep_flag_from_persistent_volumes
,
3723 """Connection to Cloud API has failed."""
3724 mock_reload_connection
.side_effect
= Exception("Can not connect to Cloud APIs.")
3725 mock_create_user_data
.return_value
= True, "userdata"
3726 mock_get_vm_availability_zone
.return_value
= "nova"
3727 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3728 mock_time
.return_value
= time_return_value
3729 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3731 self
.vimconn
.new_vminstance(
3737 affinity_group_list
,
3741 availability_zone_index
,
3742 availability_zone_list
,
3744 mock_format_exception
.assert_called_once()
3745 arg
= mock_format_exception
.call_args
[0][0]
3746 self
.assertEqual(str(arg
), "Can not connect to Cloud APIs.")
3747 mock_reload_connection
.assert_called_once()
3748 mock_prepare_network_for_vm_instance
.assert_not_called()
3749 mock_create_user_data
.assert_not_called()
3750 mock_get_vm_availability_zone
.assert_not_called()
3751 mock_prepare_disk_for_vm_instance
.assert_not_called()
3752 self
.vimconn
.nova
.servers
.create
.assert_not_called()
3753 mock_time
.assert_not_called()
3754 mock_update_port_security
.assert_not_called()
3755 mock_prepare_external_network
.assert_not_called()
3756 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3757 mock_delete_vm_instance
.assert_called_once_with(None, {})
3759 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3760 def test_delete_vm_ports_attached_to_network_empty_created_items(
3761 self
, mock_delete_ports_by_id_wth_neutron
3763 """Created_items is emtpty."""
3765 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3766 self
.vimconn
.neutron
.list_ports
.assert_not_called()
3767 self
.vimconn
.neutron
.delete_port
.assert_not_called()
3768 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3770 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3771 def test_delete_vm_ports_attached_to_network(
3772 self
, mock_delete_ports_by_id_wth_neutron
3775 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
3776 f
"volume:{volume_id2}": True,
3777 f
"volume:{volume_id}": True,
3778 f
"port:{port_id}": True,
3780 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3781 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3782 self
.vimconn
.logger
.error
.assert_not_called()
3784 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3785 def test_delete_vm_ports_attached_to_network_wthout_port(
3786 self
, mock_delete_ports_by_id_wth_neutron
3788 """Created_items does not have port."""
3790 f
"floating_ip:{floating_network_vim_id}": True,
3791 f
"volume:{volume_id2}": True,
3792 f
"volume:{volume_id}": True,
3794 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3795 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3796 self
.vimconn
.logger
.error
.assert_not_called()
3798 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3799 def test_delete_vm_ports_attached_to_network_delete_port_raise_vimconnexception(
3800 self
, mock_delete_ports_by_id_wth_neutron
3802 """_delete_ports_by_id_wth_neutron raises vimconnexception."""
3803 created_items
= deepcopy(created_items_all_true
)
3804 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
3805 "Can not delete port"
3807 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3808 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3809 self
.vimconn
.logger
.error
.assert_called_once_with(
3810 "Error deleting port: VimConnException: Can not delete port"
3813 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3814 def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
3815 self
, mock_delete_ports_by_id_wth_neutron
3817 """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
3818 created_items
= deepcopy(created_items_all_true
)
3819 mock_delete_ports_by_id_wth_neutron
.side_effect
= nvExceptions
.ClientException(
3820 "Connection aborted."
3822 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3823 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3824 self
.vimconn
.logger
.error
.assert_called_once_with(
3825 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
3828 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3829 def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
3830 self
, mock_delete_ports_by_id_wth_neutron
3832 """port item is invalid."""
3834 f
"floating_ip:{floating_network_vim_id}": True,
3835 f
"volume:{volume_id2}": True,
3836 f
"volume:{volume_id}": True,
3837 f
"port:{port_id}:": True,
3839 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
3840 "Port is not valid."
3842 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3843 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}:")
3844 self
.vimconn
.logger
.error
.assert_called_once_with(
3845 "Error deleting port: VimConnException: Port is not valid."
3848 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3849 def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
3850 self
, mock_delete_ports_by_id_wth_neutron
3852 """port is already deleted."""
3854 f
"floating_ip:{floating_network_vim_id}": True,
3855 f
"volume:{volume_id2}": True,
3856 f
"volume:{volume_id}": None,
3857 f
"port:{port_id}": None,
3859 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3860 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3861 self
.vimconn
.logger
.error
.assert_not_called()
3863 def test_delete_floating_ip_by_id(self
):
3865 f
"floating_ip:{floating_network_vim_id}": True,
3866 f
"port:{port_id}": True,
3868 expected_created_items
= {
3869 f
"floating_ip:{floating_network_vim_id}": None,
3870 f
"port:{port_id}": True,
3872 k_id
= floating_network_vim_id
3873 k
= f
"floating_ip:{floating_network_vim_id}"
3874 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3875 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3876 self
.assertEqual(created_items
, expected_created_items
)
3878 def test_delete_floating_ip_by_id_floating_ip_already_deleted(self
):
3879 """floating ip is already deleted."""
3881 f
"floating_ip:{floating_network_vim_id}": None,
3882 f
"port:{port_id}": True,
3884 k_id
= floating_network_vim_id
3885 k
= f
"floating_ip:{floating_network_vim_id}"
3886 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3887 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3891 f
"floating_ip:{floating_network_vim_id}": None,
3892 f
"port:{port_id}": True,
3896 def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self
):
3897 """netron delete floating ip raises nvExceptions.ClientException."""
3899 f
"floating_ip:{floating_network_vim_id}": True,
3900 f
"port:{port_id}": True,
3902 k_id
= floating_network_vim_id
3903 k
= f
"floating_ip:{floating_network_vim_id}"
3904 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= (
3905 nvExceptions
.ClientException("Client exception occurred.")
3907 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3908 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3912 f
"floating_ip:{floating_network_vim_id}": True,
3913 f
"port:{port_id}": True,
3916 self
.vimconn
.logger
.error
.assert_called_once_with(
3917 "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occurred.)"
3920 def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self
):
3921 """netron delete floating ip raises VimConnNotFoundException."""
3923 f
"floating_ip:{floating_network_vim_id}": True,
3924 f
"port:{port_id}": True,
3926 k_id
= floating_network_vim_id
3927 k
= f
"floating_ip:{floating_network_vim_id}"
3928 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= VimConnNotFoundException(
3929 "Port id could not found."
3931 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3932 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3936 f
"floating_ip:{floating_network_vim_id}": True,
3937 f
"port:{port_id}": True,
3940 self
.vimconn
.logger
.error
.assert_called_once_with(
3941 "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
3944 def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self
):
3945 """invalid floating ip item."""
3947 f
"floating_ip:{floating_network_vim_id}": True,
3948 f
"port:{port_id}": True,
3950 expected_created_items
= {
3951 f
"floating_ip:{floating_network_vim_id}::": None,
3952 f
"floating_ip:{floating_network_vim_id}": True,
3953 f
"port:{port_id}": True,
3955 k_id
= floating_network_vim_id
3956 k
= f
"floating_ip:{floating_network_vim_id}::"
3957 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3958 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3959 self
.assertEqual(created_items
, expected_created_items
)
3961 def test_delete_volumes_by_id_with_cinder_volume_status_available(self
):
3962 """volume status is available."""
3964 f
"floating_ip:{floating_network_vim_id}": True,
3965 f
"volume:{volume_id2}": True,
3966 f
"volume:{volume_id}": True,
3967 f
"port:{port_id}": None,
3969 expected_created_items
= {
3970 f
"floating_ip:{floating_network_vim_id}": True,
3971 f
"volume:{volume_id2}": True,
3972 f
"volume:{volume_id}": None,
3973 f
"port:{port_id}": None,
3975 volumes_to_hold
= []
3976 k
= f
"volume:{volume_id}"
3978 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
3979 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
3980 k
, k_id
, volumes_to_hold
, created_items
3982 self
.assertEqual(result
, None)
3983 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
3984 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
3985 self
.vimconn
.logger
.error
.assert_not_called()
3986 self
.assertEqual(created_items
, expected_created_items
)
3988 def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self
):
3989 """volume is already deleted."""
3991 f
"floating_ip:{floating_network_vim_id}": True,
3992 f
"volume:{volume_id2}": True,
3993 f
"volume:{volume_id}": None,
3994 f
"port:{port_id}": None,
3996 expected_created_items
= {
3997 f
"floating_ip:{floating_network_vim_id}": True,
3998 f
"volume:{volume_id2}": True,
3999 f
"volume:{volume_id}": None,
4000 f
"port:{port_id}": None,
4002 volumes_to_hold
= []
4003 k
= f
"volume:{volume_id}"
4005 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4006 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4007 k
, k_id
, volumes_to_hold
, created_items
4009 self
.assertEqual(result
, None)
4010 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4011 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4012 self
.vimconn
.logger
.error
.assert_not_called()
4013 self
.assertEqual(created_items
, expected_created_items
)
4015 def test_delete_shared_volumes(self
):
4016 """cinder delete shared volumes"""
4017 shared_volume_vim_id
= volume_id4
4018 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4019 self
.vimconn
.delete_shared_volumes(shared_volume_vim_id
)
4020 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(shared_volume_vim_id
)
4021 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(shared_volume_vim_id
)
4022 self
.vimconn
.logger
.error
.assert_not_called()
4024 def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self
):
4025 """cinder get volume raises exception."""
4027 f
"floating_ip:{floating_network_vim_id}": True,
4028 f
"volume:{volume_id2}": True,
4029 f
"volume:{volume_id}": True,
4030 f
"port:{port_id}": None,
4032 expected_created_items
= {
4033 f
"floating_ip:{floating_network_vim_id}": True,
4034 f
"volume:{volume_id2}": True,
4035 f
"volume:{volume_id}": True,
4036 f
"port:{port_id}": None,
4038 volumes_to_hold
= []
4039 k
= f
"volume:{volume_id}"
4041 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception(
4042 "Can not get volume status."
4044 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4045 k
, k_id
, volumes_to_hold
, created_items
4047 self
.assertEqual(result
, None)
4048 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4049 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4050 self
.vimconn
.logger
.error
.assert_called_once_with(
4051 "Error deleting volume: Exception: Can not get volume status."
4053 self
.assertEqual(created_items
, expected_created_items
)
4055 def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self
):
4056 """cinder delete volume raises exception."""
4058 f
"floating_ip:{floating_network_vim_id}": True,
4059 f
"volume:{volume_id2}": True,
4060 f
"volume:{volume_id}": True,
4061 f
"port:{port_id}": None,
4063 expected_created_items
= {
4064 f
"floating_ip:{floating_network_vim_id}": True,
4065 f
"volume:{volume_id2}": True,
4066 f
"volume:{volume_id}": True,
4067 f
"port:{port_id}": None,
4069 volumes_to_hold
= []
4070 k
= f
"volume:{volume_id}"
4072 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4073 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= nvExceptions
.ClientException(
4074 "Connection aborted."
4076 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4077 k
, k_id
, volumes_to_hold
, created_items
4079 self
.assertEqual(result
, None)
4080 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4081 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4082 self
.vimconn
.logger
.error
.assert_called_once_with(
4083 "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
4085 self
.assertEqual(created_items
, expected_created_items
)
4087 def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self
):
4088 """volume_to_hold has item."""
4090 f
"floating_ip:{floating_network_vim_id}": True,
4091 f
"volume:{volume_id2}": True,
4092 f
"volume:{volume_id}": True,
4093 f
"port:{port_id}": None,
4095 expected_created_items
= {
4096 f
"floating_ip:{floating_network_vim_id}": True,
4097 f
"volume:{volume_id2}": True,
4098 f
"volume:{volume_id}": True,
4099 f
"port:{port_id}": None,
4101 volumes_to_hold
= [volume_id
]
4102 k
= f
"volume:{volume_id}"
4104 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4105 k
, k_id
, volumes_to_hold
, created_items
4107 self
.assertEqual(result
, None)
4108 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
4109 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4110 self
.vimconn
.logger
.error
.assert_not_called()
4111 self
.assertEqual(created_items
, expected_created_items
)
4113 def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self
):
4114 """volume status is not available."""
4116 f
"floating_ip:{floating_network_vim_id}": True,
4117 f
"volume:{volume_id2}": True,
4118 f
"volume:{volume_id}": True,
4119 f
"port:{port_id}": None,
4121 expected_created_items
= {
4122 f
"floating_ip:{floating_network_vim_id}": True,
4123 f
"volume:{volume_id2}": True,
4124 f
"volume:{volume_id}": True,
4125 f
"port:{port_id}": None,
4127 volumes_to_hold
= []
4128 k
= f
"volume:{volume_id}"
4130 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "unavailable"
4131 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4132 k
, k_id
, volumes_to_hold
, created_items
4134 self
.assertEqual(result
, True)
4135 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4136 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4137 self
.vimconn
.logger
.error
.assert_not_called()
4138 self
.assertEqual(created_items
, expected_created_items
)
4140 def test_delete_ports_by_id_by_neutron(self
):
4141 """neutron delete ports."""
4143 self
.vimconn
.neutron
.list_ports
.return_value
= {
4144 "ports": [{"id": port_id
}, {"id": port2_id
}]
4147 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4148 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4149 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4150 self
.vimconn
.logger
.error
.assert_not_called()
4152 def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self
):
4153 """port id not in the port list."""
4155 self
.vimconn
.neutron
.list_ports
.return_value
= {
4156 "ports": [{"id": port_id
}, {"id": port2_id
}]
4159 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4160 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4161 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4162 self
.vimconn
.logger
.error
.assert_not_called()
4164 def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self
):
4165 """neutron list port raises exception."""
4167 self
.vimconn
.neutron
.list_ports
.side_effect
= nvExceptions
.ClientException(
4168 "Connection aborted."
4170 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4171 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4172 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4173 self
.vimconn
.logger
.error
.assert_called_once_with(
4174 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4177 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
4178 """neutron delete port raises exception."""
4180 self
.vimconn
.neutron
.list_ports
.return_value
= {
4181 "ports": [{"id": port_id
}, {"id": port2_id
}]
4183 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
4184 "Connection aborted."
4186 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4187 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4188 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4189 self
.vimconn
.logger
.error
.assert_called_once_with(
4190 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4193 def test_get_item_name_id(self
):
4194 """Get name and id successfully."""
4195 k
= f
"some:{port_id}"
4196 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4197 self
.assertEqual(result
, ("some", f
"{port_id}"))
4199 def test_get_item_name_id_wthout_semicolon(self
):
4200 """Does not have seperator."""
4201 k
= f
"some{port_id}"
4202 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4203 self
.assertEqual(result
, (f
"some{port_id}", ""))
4205 def test_get_item_name_id_empty_string(self
):
4208 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4209 self
.assertEqual(result
, ("", ""))
4211 def test_get_item_name_id_k_is_none(self
):
4214 with self
.assertRaises(AttributeError):
4215 self
.vimconn
._get
_item
_name
_id
(k
)
4217 @patch.object(vimconnector
, "_get_item_name_id")
4218 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4219 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4220 def test_delete_created_items(
4222 mock_delete_floating_ip_by_id
,
4223 mock_delete_volumes_by_id_wth_cinder
,
4224 mock_get_item_name_id
,
4226 """Created items has floating ip and volume."""
4228 f
"floating_ip:{floating_network_vim_id}": True,
4229 f
"volume:{volume_id}": True,
4230 f
"port:{port_id}": None,
4232 mock_get_item_name_id
.side_effect
= [
4233 ("floating_ip", f
"{floating_network_vim_id}"),
4234 ("volume", f
"{volume_id}"),
4236 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4237 volumes_to_hold
= []
4238 keep_waiting
= False
4239 result
= self
.vimconn
._delete
_created
_items
(
4240 created_items
, volumes_to_hold
, keep_waiting
4242 self
.assertEqual(result
, True)
4243 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4244 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4245 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4247 mock_delete_floating_ip_by_id
.assert_called_once_with(
4248 f
"floating_ip:{floating_network_vim_id}",
4249 f
"{floating_network_vim_id}",
4252 self
.vimconn
.logger
.error
.assert_not_called()
4254 @patch.object(vimconnector
, "_get_item_name_id")
4255 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4256 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4257 def test_delete_created_items_wth_volumes_to_hold(
4259 mock_delete_floating_ip_by_id
,
4260 mock_delete_volumes_by_id_wth_cinder
,
4261 mock_get_item_name_id
,
4263 """Created items has floating ip and volume and volumes_to_hold has items."""
4265 f
"floating_ip:{floating_network_vim_id}": True,
4266 f
"volume:{volume_id}": True,
4267 f
"port:{port_id}": None,
4269 mock_get_item_name_id
.side_effect
= [
4270 ("floating_ip", f
"{floating_network_vim_id}"),
4271 ("volume", f
"{volume_id}"),
4273 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4274 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4275 keep_waiting
= False
4276 result
= self
.vimconn
._delete
_created
_items
(
4277 created_items
, volumes_to_hold
, keep_waiting
4279 self
.assertEqual(result
, True)
4280 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4281 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4282 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4284 mock_delete_floating_ip_by_id
.assert_called_once_with(
4285 f
"floating_ip:{floating_network_vim_id}",
4286 f
"{floating_network_vim_id}",
4289 self
.vimconn
.logger
.error
.assert_not_called()
4291 @patch.object(vimconnector
, "_get_item_name_id")
4292 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4293 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4294 def test_delete_created_items_wth_keep_waiting_true(
4296 mock_delete_floating_ip_by_id
,
4297 mock_delete_volumes_by_id_wth_cinder
,
4298 mock_get_item_name_id
,
4300 """Keep waiting initial value is True."""
4302 f
"floating_ip:{floating_network_vim_id}": True,
4303 f
"volume:{volume_id}": True,
4304 f
"port:{port_id}": None,
4306 mock_get_item_name_id
.side_effect
= [
4307 ("floating_ip", f
"{floating_network_vim_id}"),
4308 ("volume", f
"{volume_id}"),
4310 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4311 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4313 result
= self
.vimconn
._delete
_created
_items
(
4314 created_items
, volumes_to_hold
, keep_waiting
4316 self
.assertEqual(result
, True)
4317 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4318 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4319 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4321 mock_delete_floating_ip_by_id
.assert_called_once_with(
4322 f
"floating_ip:{floating_network_vim_id}",
4323 f
"{floating_network_vim_id}",
4326 self
.vimconn
.logger
.error
.assert_not_called()
4328 @patch.object(vimconnector
, "_get_item_name_id")
4329 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4330 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4331 def test_delete_created_items_delete_vol_raises(
4333 mock_delete_floating_ip_by_id
,
4334 mock_delete_volumes_by_id_wth_cinder
,
4335 mock_get_item_name_id
,
4337 """Delete volume raises exception."""
4339 f
"floating_ip:{floating_network_vim_id}": True,
4340 f
"volume:{volume_id}": True,
4341 f
"port:{port_id}": None,
4343 mock_get_item_name_id
.side_effect
= [
4344 ("floating_ip", f
"{floating_network_vim_id}"),
4345 ("volume", f
"{volume_id}"),
4347 mock_delete_volumes_by_id_wth_cinder
.side_effect
= ConnectionError(
4348 "Connection failed."
4350 volumes_to_hold
= []
4351 keep_waiting
= False
4352 result
= self
.vimconn
._delete
_created
_items
(
4353 created_items
, volumes_to_hold
, keep_waiting
4355 self
.assertEqual(result
, False)
4356 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4357 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4358 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4360 mock_delete_floating_ip_by_id
.assert_called_once_with(
4361 f
"floating_ip:{floating_network_vim_id}",
4362 f
"{floating_network_vim_id}",
4365 self
.vimconn
.logger
.error
.assert_called_once_with(
4366 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
4369 @patch.object(vimconnector
, "_get_item_name_id")
4370 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4371 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4372 def test_delete_created_items_delete_fip_raises(
4374 mock_delete_floating_ip_by_id
,
4375 mock_delete_volumes_by_id_wth_cinder
,
4376 mock_get_item_name_id
,
4378 """Delete floating ip raises exception."""
4380 f
"floating_ip:{floating_network_vim_id}": True,
4381 f
"volume:{volume_id}": True,
4382 f
"port:{port_id}": None,
4384 mock_get_item_name_id
.side_effect
= [
4385 ("floating_ip", f
"{floating_network_vim_id}"),
4386 ("volume", f
"{volume_id}"),
4388 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4389 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
4390 "Connection failed."
4392 volumes_to_hold
= []
4394 result
= self
.vimconn
._delete
_created
_items
(
4395 created_items
, volumes_to_hold
, keep_waiting
4397 self
.assertEqual(result
, True)
4398 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4399 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4400 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4402 mock_delete_floating_ip_by_id
.assert_called_once_with(
4403 f
"floating_ip:{floating_network_vim_id}",
4404 f
"{floating_network_vim_id}",
4407 self
.vimconn
.logger
.error
.assert_called_once_with(
4408 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
4411 @patch.object(vimconnector
, "_get_item_name_id")
4412 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4413 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4414 def test_delete_created_items_get_item_name_raises(
4416 mock_delete_floating_ip_by_id
,
4417 mock_delete_volumes_by_id_wth_cinder
,
4418 mock_get_item_name_id
,
4420 """Get item, name raises exception."""
4423 f
"volume{volume_id}": True,
4424 f
"port:{port_id}": None,
4426 mock_get_item_name_id
.side_effect
= [
4427 TypeError("Invalid Type"),
4428 AttributeError("Invalid attribute"),
4430 volumes_to_hold
= []
4431 keep_waiting
= False
4432 result
= self
.vimconn
._delete
_created
_items
(
4433 created_items
, volumes_to_hold
, keep_waiting
4435 self
.assertEqual(result
, False)
4436 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4437 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4438 mock_delete_floating_ip_by_id
.assert_not_called()
4439 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
4440 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
4443 (f
"Error deleting volume{volume_id}: Invalid attribute",),
4446 @patch.object(vimconnector
, "_get_item_name_id")
4447 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4448 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4449 def test_delete_created_items_no_fip_wth_port(
4451 mock_delete_floating_ip_by_id
,
4452 mock_delete_volumes_by_id_wth_cinder
,
4453 mock_get_item_name_id
,
4455 """Created items has port, does not have floating ip."""
4457 f
"volume:{volume_id}": True,
4458 f
"port:{port_id}": True,
4460 mock_get_item_name_id
.side_effect
= [
4461 ("volume", f
"{volume_id}"),
4462 ("port", f
"{port_id}"),
4464 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4465 volumes_to_hold
= []
4466 keep_waiting
= False
4467 result
= self
.vimconn
._delete
_created
_items
(
4468 created_items
, volumes_to_hold
, keep_waiting
4470 self
.assertEqual(result
, False)
4471 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4472 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4473 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4475 mock_delete_floating_ip_by_id
.assert_not_called()
4476 self
.vimconn
.logger
.error
.assert_not_called()
4478 @patch.object(vimconnector
, "_get_item_name_id")
4479 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4480 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4481 def test_delete_created_items_no_volume(
4483 mock_delete_floating_ip_by_id
,
4484 mock_delete_volumes_by_id_wth_cinder
,
4485 mock_get_item_name_id
,
4487 """Created items does not have volume."""
4489 f
"floating_ip:{floating_network_vim_id}": True,
4490 f
"port:{port_id}": None,
4492 mock_get_item_name_id
.side_effect
= [
4493 ("floating_ip", f
"{floating_network_vim_id}")
4495 volumes_to_hold
= []
4496 keep_waiting
= False
4497 result
= self
.vimconn
._delete
_created
_items
(
4498 created_items
, volumes_to_hold
, keep_waiting
4500 self
.assertEqual(result
, False)
4501 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
4502 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4503 mock_delete_floating_ip_by_id
.assert_called_once_with(
4504 f
"floating_ip:{floating_network_vim_id}",
4505 f
"{floating_network_vim_id}",
4508 self
.vimconn
.logger
.error
.assert_not_called()
4510 @patch.object(vimconnector
, "_get_item_name_id")
4511 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4512 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4513 def test_delete_created_items_already_deleted(
4515 mock_delete_floating_ip_by_id
,
4516 mock_delete_volumes_by_id_wth_cinder
,
4517 mock_get_item_name_id
,
4519 """All created items are alerady deleted."""
4521 f
"floating_ip:{floating_network_vim_id}": None,
4522 f
"volume:{volume_id}": None,
4523 f
"port:{port_id}": None,
4525 volumes_to_hold
= []
4526 keep_waiting
= False
4527 result
= self
.vimconn
._delete
_created
_items
(
4528 created_items
, volumes_to_hold
, keep_waiting
4530 self
.assertEqual(result
, False)
4531 mock_get_item_name_id
.assert_not_called()
4532 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4533 mock_delete_floating_ip_by_id
.assert_not_called()
4534 self
.vimconn
.logger
.error
.assert_not_called()
4536 @patch("time.sleep")
4537 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4538 @patch.object(vimconnector
, "_format_exception")
4539 @patch.object(vimconnector
, "_reload_connection")
4540 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4541 @patch.object(vimconnector
, "_delete_created_items")
4542 def test_delete_vminstance_successfully(
4544 mock_delete_created_items
,
4545 mock_delete_vm_ports_attached_to_network
,
4546 mock_reload_connection
,
4547 mock_format_exception
,
4548 mock_extract_items_wth_keep_flag_from_created_items
,
4551 vm_id
= f
"{virtual_mac_id}"
4552 created_items
= deepcopy(created_items_all_true
)
4553 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4554 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4555 mock_delete_created_items
.return_value
= False
4556 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4557 mock_reload_connection
.assert_called_once()
4558 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4559 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4560 mock_delete_created_items
.assert_called_once_with(
4561 created_items
, volumes_to_hold
, False
4563 mock_sleep
.assert_not_called()
4564 mock_format_exception
.assert_not_called()
4565 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4569 @patch("time.sleep")
4570 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4571 @patch.object(vimconnector
, "_format_exception")
4572 @patch.object(vimconnector
, "_reload_connection")
4573 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4574 @patch.object(vimconnector
, "_delete_created_items")
4575 def test_delete_vminstance_created_items_has_keep_flag(
4577 mock_delete_created_items
,
4578 mock_delete_vm_ports_attached_to_network
,
4579 mock_reload_connection
,
4580 mock_format_exception
,
4581 mock_extract_items_wth_keep_flag_from_created_items
,
4584 """Created_items includes items which has keep flag."""
4585 vm_id
= f
"{virtual_mac_id}"
4586 initial_created_items
= {
4587 f
"port{port_id}": True,
4588 f
"floating_ip{floating_network_vim_id}": None,
4589 f
"volume{volume_id}keep": True,
4590 f
"volume{volume_id2}keep": True,
4593 f
"port{port_id}": True,
4594 f
"floating_ip{floating_network_vim_id}": None,
4596 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4597 volumes_to_hold
= []
4598 mock_delete_created_items
.return_value
= False
4599 self
.vimconn
.delete_vminstance(vm_id
, initial_created_items
, volumes_to_hold
)
4600 mock_reload_connection
.assert_called_once()
4601 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4602 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4603 mock_delete_created_items
.assert_called_once_with(
4604 created_items
, volumes_to_hold
, False
4606 mock_sleep
.assert_not_called()
4607 mock_format_exception
.assert_not_called()
4608 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4609 initial_created_items
4612 @patch("time.sleep")
4613 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4614 @patch.object(vimconnector
, "_format_exception")
4615 @patch.object(vimconnector
, "_reload_connection")
4616 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4617 @patch.object(vimconnector
, "_delete_created_items")
4618 def test_delete_vminstance_extract_items_wth_keep_raises(
4620 mock_delete_created_items
,
4621 mock_delete_vm_ports_attached_to_network
,
4622 mock_reload_connection
,
4623 mock_format_exception
,
4624 mock_extract_items_wth_keep_flag_from_created_items
,
4627 """extract_items_wth_keep_flag_from_created_items raises AttributeError."""
4628 vm_id
= f
"{virtual_mac_id}"
4629 initial_created_items
= {
4630 f
"port{port_id}": True,
4631 f
"floating_ip{floating_network_vim_id}": None,
4632 f
"volume{volume_id}keep": True,
4633 f
"volume{volume_id2}keep": True,
4636 mock_extract_items_wth_keep_flag_from_created_items
.side_effect
= AttributeError
4637 volumes_to_hold
= []
4638 mock_delete_created_items
.return_value
= False
4639 with self
.assertRaises(AttributeError):
4640 self
.vimconn
.delete_vminstance(
4641 vm_id
, initial_created_items
, volumes_to_hold
4643 mock_reload_connection
.assert_not_called()
4644 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4645 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4646 mock_delete_created_items
.assert_not_called()
4647 mock_sleep
.assert_not_called()
4648 mock_format_exception
.assert_not_called()
4649 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4650 initial_created_items
4653 @patch("time.sleep")
4654 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4655 @patch.object(vimconnector
, "_format_exception")
4656 @patch.object(vimconnector
, "_reload_connection")
4657 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4658 @patch.object(vimconnector
, "_delete_created_items")
4659 def test_delete_vminstance_delete_created_items_raises(
4661 mock_delete_created_items
,
4662 mock_delete_vm_ports_attached_to_network
,
4663 mock_reload_connection
,
4664 mock_format_exception
,
4665 mock_extract_items_wth_keep_flag_from_created_items
,
4668 """Delete creted items raises exception."""
4669 vm_id
= f
"{virtual_mac_id}"
4670 created_items
= deepcopy(created_items_all_true
)
4671 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4672 mock_sleep
= MagicMock()
4673 volumes_to_hold
= []
4674 err
= ConnectionError("ClientException occurred.")
4675 mock_delete_created_items
.side_effect
= err
4676 with self
.assertRaises(ConnectionError
) as err
:
4677 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4678 self
.assertEqual(str(err
), "ClientException occurred.")
4679 mock_reload_connection
.assert_called_once()
4680 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4681 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4682 mock_delete_created_items
.assert_called_once()
4683 mock_sleep
.assert_not_called()
4684 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4688 @patch("time.sleep")
4689 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4690 @patch.object(vimconnector
, "_format_exception")
4691 @patch.object(vimconnector
, "_reload_connection")
4692 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4693 @patch.object(vimconnector
, "_delete_created_items")
4694 def test_delete_vminstance_delete_vm_ports_raises(
4696 mock_delete_created_items
,
4697 mock_delete_vm_ports_attached_to_network
,
4698 mock_reload_connection
,
4699 mock_format_exception
,
4700 mock_extract_items_wth_keep_flag_from_created_items
,
4703 """Delete vm ports raises exception."""
4704 vm_id
= f
"{virtual_mac_id}"
4705 created_items
= deepcopy(created_items_all_true
)
4706 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4707 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4708 err
= ConnectionError("ClientException occurred.")
4709 mock_delete_vm_ports_attached_to_network
.side_effect
= err
4710 mock_delete_created_items
.side_effect
= err
4711 with self
.assertRaises(ConnectionError
) as err
:
4712 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4713 self
.assertEqual(str(err
), "ClientException occurred.")
4714 mock_reload_connection
.assert_called_once()
4715 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4716 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4717 mock_delete_created_items
.assert_not_called()
4718 mock_sleep
.assert_not_called()
4719 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4723 @patch("time.sleep")
4724 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4725 @patch.object(vimconnector
, "_format_exception")
4726 @patch.object(vimconnector
, "_reload_connection")
4727 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4728 @patch.object(vimconnector
, "_delete_created_items")
4729 def test_delete_vminstance_nova_server_delete_raises(
4731 mock_delete_created_items
,
4732 mock_delete_vm_ports_attached_to_network
,
4733 mock_reload_connection
,
4734 mock_format_exception
,
4735 mock_extract_items_wth_keep_flag_from_created_items
,
4738 """Nova server delete raises exception."""
4739 vm_id
= f
"{virtual_mac_id}"
4740 created_items
= deepcopy(created_items_all_true
)
4741 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4742 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4743 err
= VimConnConnectionException("ClientException occurred.")
4744 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
4745 mock_delete_created_items
.side_effect
= err
4746 with self
.assertRaises(VimConnConnectionException
) as err
:
4747 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4748 self
.assertEqual(str(err
), "ClientException occurred.")
4749 mock_reload_connection
.assert_called_once()
4750 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4751 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4752 mock_delete_created_items
.assert_not_called()
4753 mock_sleep
.assert_not_called()
4754 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4758 @patch("time.sleep")
4759 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4760 @patch.object(vimconnector
, "_format_exception")
4761 @patch.object(vimconnector
, "_reload_connection")
4762 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4763 @patch.object(vimconnector
, "_delete_created_items")
4764 def test_delete_vminstance_reload_connection_raises(
4766 mock_delete_created_items
,
4767 mock_delete_vm_ports_attached_to_network
,
4768 mock_reload_connection
,
4769 mock_format_exception
,
4770 mock_extract_items_wth_keep_flag_from_created_items
,
4773 """Reload connection raises exception."""
4774 vm_id
= f
"{virtual_mac_id}"
4775 created_items
= deepcopy(created_items_all_true
)
4776 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4777 mock_sleep
= MagicMock()
4778 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4779 err
= ConnectionError("ClientException occurred.")
4780 mock_delete_created_items
.return_value
= False
4781 mock_reload_connection
.side_effect
= err
4782 with self
.assertRaises(ConnectionError
) as err
:
4783 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4784 self
.assertEqual(str(err
), "ClientException occurred.")
4785 mock_reload_connection
.assert_called_once()
4786 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4787 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4788 mock_delete_created_items
.assert_not_called()
4789 mock_sleep
.assert_not_called()
4790 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4794 @patch("time.sleep")
4795 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4796 @patch.object(vimconnector
, "_format_exception")
4797 @patch.object(vimconnector
, "_reload_connection")
4798 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4799 @patch.object(vimconnector
, "_delete_created_items")
4800 def test_delete_vminstance_created_item_vol_to_hold_are_none(
4802 mock_delete_created_items
,
4803 mock_delete_vm_ports_attached_to_network
,
4804 mock_reload_connection
,
4805 mock_format_exception
,
4806 mock_extract_items_wth_keep_flag_from_created_items
,
4809 """created_items and volumes_to_hold are None."""
4810 vm_id
= f
"{virtual_mac_id}"
4811 created_items
= None
4812 volumes_to_hold
= None
4813 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= {}
4814 mock_delete_created_items
.return_value
= False
4815 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4816 mock_reload_connection
.assert_called_once()
4817 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4818 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4819 mock_delete_created_items
.assert_called_once_with({}, [], False)
4820 mock_sleep
.assert_not_called()
4821 mock_format_exception
.assert_not_called()
4822 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with({})
4824 @patch("time.sleep")
4825 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4826 @patch.object(vimconnector
, "_format_exception")
4827 @patch.object(vimconnector
, "_reload_connection")
4828 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4829 @patch.object(vimconnector
, "_delete_created_items")
4830 def test_delete_vminstance_vm_id_is_none(
4832 mock_delete_created_items
,
4833 mock_delete_vm_ports_attached_to_network
,
4834 mock_reload_connection
,
4835 mock_format_exception
,
4836 mock_extract_items_wth_keep_flag_from_created_items
,
4839 """vm_id is None."""
4841 created_items
= deepcopy(created_items_all_true
)
4842 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4843 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4844 mock_delete_created_items
.side_effect
= [True, True, False]
4845 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4846 mock_reload_connection
.assert_called_once()
4847 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4848 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4849 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
4850 self
.assertEqual(mock_sleep
.call_count
, 2)
4851 mock_format_exception
.assert_not_called()
4852 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4856 @patch("time.sleep")
4857 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4858 @patch.object(vimconnector
, "_format_exception")
4859 @patch.object(vimconnector
, "_reload_connection")
4860 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4861 @patch.object(vimconnector
, "_delete_created_items")
4862 def test_delete_vminstance_delete_created_items_return_true(
4864 mock_delete_created_items
,
4865 mock_delete_vm_ports_attached_to_network
,
4866 mock_reload_connection
,
4867 mock_format_exception
,
4868 mock_extract_items_wth_keep_flag_from_created_items
,
4871 """Delete created items always return True."""
4873 created_items
= deepcopy(created_items_all_true
)
4874 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4875 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4876 mock_delete_created_items
.side_effect
= [True] * 1800
4877 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4878 mock_reload_connection
.assert_called_once()
4879 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4880 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4881 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
4882 self
.assertEqual(mock_sleep
.call_count
, 1800)
4883 mock_format_exception
.assert_not_called()
4884 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4888 def test_remove_keep_tag_from_persistent_volumes_keep_flag_exists(self
):
4889 """Keep flag exists in created items."""
4891 f
"port:{port_id}": True,
4892 f
"floating_ip:{floating_network_vim_id}": True,
4893 f
"volume:{volume_id}:keep": True,
4894 f
"volume:{volume_id2}:keep": True,
4897 f
"port:{port_id}": True,
4898 f
"floating_ip:{floating_network_vim_id}": True,
4899 f
"volume:{volume_id}": True,
4900 f
"volume:{volume_id2}": True,
4902 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4903 self
.assertDictEqual(result
, expected_result
)
4905 def test_remove_keep_tag_from_persistent_volumes_without_keep_flag(self
):
4906 """Keep flag does not exist in created items."""
4908 f
"port:{port_id}": True,
4909 f
"floating_ip:{floating_network_vim_id}": True,
4910 f
"volume:{volume_id}": True,
4911 f
"volume:{volume_id2}": True,
4913 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4914 self
.assertDictEqual(result
, created_items
)
4916 def test_update_block_device_mapping_empty_volume(self
):
4918 block_device_mapping
= {}
4919 base_disk_index
= 100
4922 with self
.assertRaises(VimConnException
) as err
:
4923 self
.vimconn
.update_block_device_mapping(
4924 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4926 self
.assertEqual(str(err
), "Volume is empty.")
4927 self
.assertEqual(block_device_mapping
, {})
4928 self
.assertEqual(created_items
, {})
4930 def test_update_block_device_mapping_invalid_volume(self
):
4932 block_device_mapping
= {}
4933 base_disk_index
= 100
4936 with self
.assertRaises(VimConnException
) as err
:
4937 self
.vimconn
.update_block_device_mapping(
4938 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4941 str(err
), "Created volume is not valid, does not have id attribute."
4943 self
.assertEqual(block_device_mapping
, {})
4944 self
.assertEqual(created_items
, {})
4946 def test_update_block_device_mapping(self
):
4947 volume
= MagicMock(autospec
=True)
4948 volume
.id = volume_id
4949 block_device_mapping
= {}
4950 base_disk_index
= 100
4953 self
.vimconn
.update_block_device_mapping(
4954 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4957 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4960 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a": True}
4963 def test_update_block_device_mapping_with_keep_flag(self
):
4964 volume
= MagicMock(autospec
=True)
4965 volume
.id = volume_id
4966 block_device_mapping
= {}
4967 base_disk_index
= 100
4968 disk
= {"size": 10, "keep": True}
4970 self
.vimconn
.update_block_device_mapping(
4971 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4974 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4977 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a:keep": True}
4980 def test_extract_items_with_keep_flag_item_has_keep_flag(self
):
4981 created_items
= deepcopy(created_items_all_true
)
4982 created_items
[f
"volume:{volume_id2}:keep"] = True
4983 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4986 self
.assertEqual(result
, deepcopy(created_items_all_true
))
4988 def test_extract_items_with_keep_flag_no_item_wth_keep_flag(self
):
4989 created_items
= deepcopy(created_items_all_true
)
4990 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4993 self
.assertEqual(result
, deepcopy(created_items_all_true
))
4995 def test_extract_items_with_keep_flag_all_items_are_already_deleted(self
):
4997 f
"port:{port_id}": None,
4998 f
"floating_ip:{floating_network_vim_id}": None,
4999 f
"volume:{volume_id}:keep": None,
5000 f
"volume:{volume_id2}:keep": None,
5003 f
"port:{port_id}": None,
5004 f
"floating_ip:{floating_network_vim_id}": None,
5006 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5009 self
.assertEqual(result
, expected_result
)
5011 def test_extract_items_with_keep_flag_without_semicolon(self
):
5013 f
"port{port_id}": True,
5014 f
"floating_ip{floating_network_vim_id}": None,
5015 f
"volume{volume_id}keep": True,
5016 f
"volume{volume_id2}keep": True,
5018 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5021 self
.assertEqual(result
, {})
5023 def test_extract_items_with_keep_flag_invalid_type_created_items(self
):
5024 created_items
= [{f
"port{port_id}": True}, {f
"volume{volume_id2}keep": True}]
5025 with self
.assertRaises(AttributeError):
5026 self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(created_items
)
5028 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5029 def test_get_monitoring_data(self
, mock_reload_conection
):
5031 {"original_name": "flavor1", "id": "367fc1eb-bd22-40f8-a519-ed2fb4e5976b"},
5032 {"original_name": "flavor2", "id": "5dcf9732-d17d-40b3-910d-37fc4c5aacc0"},
5036 "server1", "ACTIVE", flavors
[0], "312200db-42e3-4772-9518-d5db85468392"
5039 "server2", "ACTIVE", flavors
[1], "39a166cf-e4e6-479c-b88c-9ad558cf2cbf"
5042 ports
= {"ports": ["port1", "port2"]}
5043 self
.vimconn
.nova
.servers
.list.return_value
= servers
5044 self
.vimconn
.neutron
.list_ports
.return_value
= ports
5045 result
= self
.vimconn
.get_monitoring_data()
5046 self
.assertTupleEqual(result
, (servers
, ports
))
5047 mock_reload_conection
.assert_called_once()
5048 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5049 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5051 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5052 def test_get_monitoring_data_reload_connection_raises(self
, mock_reload_conection
):
5053 mock_reload_conection
.side_effect
= VimConnNotFoundException(
5054 "Connection object not found."
5056 with self
.assertRaises(VimConnException
) as err
:
5057 result
= self
.vimconn
.get_monitoring_data()
5058 self
.assertTupleEqual(result
, None)
5060 str(err
.exception
.args
[0]),
5061 "Exception in monitoring while getting VMs and ports status: Connection object not found.",
5063 mock_reload_conection
.assert_called_once()
5064 check_if_assert_not_called(
5065 [self
.vimconn
.nova
.servers
.list, self
.vimconn
.neutron
.list_ports
]
5068 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5069 def test_get_monitoring_data_server_list_raises(self
, mock_reload_conection
):
5070 self
.vimconn
.nova
.servers
.list.side_effect
= VimConnConnectionException(
5071 "Can not connect to Cloud API."
5073 with self
.assertRaises(VimConnException
) as err
:
5074 result
= self
.vimconn
.get_monitoring_data()
5075 self
.assertTupleEqual(result
, None)
5077 str(err
.exception
.args
[0]),
5078 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5080 mock_reload_conection
.assert_called_once()
5081 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5082 self
.vimconn
.neutron
.list_ports
.assert_not_called()
5084 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5085 def test_get_monitoring_data_list_ports_raises(self
, mock_reload_conection
):
5086 self
.vimconn
.neutron
.list_ports
.side_effect
= VimConnConnectionException(
5087 "Can not connect to Cloud API."
5089 with self
.assertRaises(VimConnException
) as err
:
5090 result
= self
.vimconn
.get_monitoring_data()
5091 self
.assertTupleEqual(result
, None)
5093 str(err
.exception
.args
[0]),
5094 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5096 mock_reload_conection
.assert_called_once()
5097 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5098 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5101 class TestNewFlavor(unittest
.TestCase
):
5102 @patch("logging.getLogger", autospec
=True)
5103 def setUp(self
, mock_logger
):
5104 # We are disabling the logging of exception not to print them to console.
5105 mock_logger
= logging
.getLogger()
5106 mock_logger
.disabled
= True
5107 self
.vimconn
= vimconnector(
5117 self
.vimconn
.nova
= CopyingMock(autospec
=True)
5118 self
.flavor1
= CopyingMock(autospec
=True, name
="sample-flavor")
5119 self
.flavor2
= CopyingMock(autospec
=True, name
="other-flavor")
5120 self
.new_flavor
= CopyingMock(autospec
=True, name
="new_flavor")
5121 self
.new_flavor
.id = "075d2482-5edb-43e3-91b3-234e65b6268a"
5122 self
.vimconn
.nova
.flavors
.create
.return_value
= self
.new_flavor
5124 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5125 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5126 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5129 "process_numa_paired_threads",
5130 new_callable
=CopyingMock(),
5132 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5133 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5134 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_vio(
5136 mock_process_numa_threads
,
5137 mock_process_numa_cores
,
5138 mock_process_numa_paired_threads
,
5139 mock_process_numa_vcpu
,
5140 mock_process_numa_memory
,
5141 mock_process_vio_numa_nodes
,
5143 """Process numa parameters, id, memory, vcpu exist, vim type is VIO,
5144 paired-threads, cores, threads do not exist in numa.
5147 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5148 {"id": 1, "memory": 2, "vcpu": [2]},
5151 expected_extra_specs
= {
5152 "hw:numa_nodes": "2",
5153 "hw:cpu_sockets": "2",
5155 self
.vimconn
.vim_type
= "VIO"
5156 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5158 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5159 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5160 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5161 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5163 _call_mock_process_numa_memory
[0].args
,
5165 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5168 "hw:numa_nodes": "2",
5173 _call_mock_process_numa_memory
[1].args
,
5175 {"id": 1, "memory": 2, "vcpu": [2]},
5178 "hw:cpu_sockets": "2",
5179 "hw:numa_nodes": "2",
5183 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5185 _call_mock_process_numa_vcpu
[0].args
,
5187 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5190 "hw:numa_nodes": "2",
5195 _call_mock_process_numa_vcpu
[1].args
,
5197 {"id": 1, "memory": 2, "vcpu": [2]},
5200 "hw:cpu_sockets": "2",
5201 "hw:numa_nodes": "2",
5205 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5206 check_if_assert_not_called(
5208 mock_process_numa_threads
,
5209 mock_process_numa_cores
,
5210 mock_process_numa_paired_threads
,
5214 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5215 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5216 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5219 "process_numa_paired_threads",
5220 new_callable
=CopyingMock(),
5222 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5223 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5224 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_openstack(
5226 mock_process_numa_threads
,
5227 mock_process_numa_cores
,
5228 mock_process_numa_paired_threads
,
5229 mock_process_numa_vcpu
,
5230 mock_process_numa_memory
,
5231 mock_process_vio_numa_nodes
,
5233 """Process numa parameters, id, memory, vcpu exist, vim type is openstack,
5234 paired-threads, cores, threads do not exist in numa.
5237 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5238 {"id": 1, "memory": 2, "vcpu": [2]},
5241 expected_extra_specs
= {
5242 "hw:numa_nodes": "2",
5243 "hw:cpu_sockets": "2",
5245 self
.vimconn
.vim_type
= "openstack"
5246 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5248 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5249 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5250 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5252 _call_mock_process_numa_memory
[0].args
,
5254 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5256 {"hw:numa_nodes": "2"},
5260 _call_mock_process_numa_memory
[1].args
,
5262 {"id": 1, "memory": 2, "vcpu": [2]},
5264 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5267 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5269 _call_mock_process_numa_vcpu
[0].args
,
5271 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5273 {"hw:numa_nodes": "2"},
5277 _call_mock_process_numa_vcpu
[1].args
,
5279 {"id": 1, "memory": 2, "vcpu": [2]},
5281 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5284 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5285 check_if_assert_not_called(
5287 mock_process_numa_threads
,
5288 mock_process_numa_cores
,
5289 mock_process_numa_paired_threads
,
5293 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5294 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5295 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5298 "process_numa_paired_threads",
5299 new_callable
=CopyingMock(),
5301 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5302 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5303 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_openstack_extra_spec_not_empty(
5305 mock_process_numa_threads
,
5306 mock_process_numa_cores
,
5307 mock_process_numa_paired_threads
,
5308 mock_process_numa_vcpu
,
5309 mock_process_numa_memory
,
5310 mock_process_vio_numa_nodes
,
5312 """Process numa parameters, id, paired-threads exist, vim type is openstack.
5313 vcpus calculation according to paired-threads in numa, there is extra_spec.
5315 numas
= [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
5316 extra_specs
= {"some-key": "some-value"}
5317 expected_extra_specs
= {
5318 "hw:cpu_sockets": "2",
5319 "hw:cpu_threads": "12",
5320 "hw:numa_nodes": "2",
5321 "some-key": "some-value",
5323 self
.vimconn
.vim_type
= "openstack"
5324 mock_process_numa_paired_threads
.side_effect
= [6, 6]
5325 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5327 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5328 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5329 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5330 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5331 _call_mock_process_numa_paired_threads
= (
5332 mock_process_numa_paired_threads
.call_args_list
5335 _call_mock_process_numa_paired_threads
[0].args
,
5337 {"id": 0, "paired-threads": 3},
5338 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5342 _call_mock_process_numa_paired_threads
[1].args
,
5344 {"id": 1, "paired-threads": 3},
5345 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5348 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5350 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5351 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5352 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5355 "process_numa_paired_threads",
5356 new_callable
=CopyingMock(),
5358 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5359 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5360 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_vio_extra_spec_not_empty(
5362 mock_process_numa_threads
,
5363 mock_process_numa_cores
,
5364 mock_process_numa_paired_threads
,
5365 mock_process_numa_vcpu
,
5366 mock_process_numa_memory
,
5367 mock_process_vio_numa_nodes
,
5369 """Process numa parameters, id, paired-threads exist, vim type is VIO.
5370 vcpus calculation according to paired-threads in numa, there is extra_spec.
5372 numas
= [{"id": 0, "paired-threads": 2}, {"id": 1, "paired-threads": 2}]
5373 extra_specs
= {"some-key": "some-value"}
5374 expected_extra_specs
= {
5375 "hw:numa_nodes": "2",
5376 "hw:cpu_sockets": "2",
5377 "hw:cpu_threads": "8",
5378 "some-key": "some-value",
5380 self
.vimconn
.vim_type
= "VIO"
5381 mock_process_numa_paired_threads
.side_effect
= [4, 4]
5382 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5383 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5384 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5385 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5386 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5387 _call_mock_process_numa_paired_threads
= (
5388 mock_process_numa_paired_threads
.call_args_list
5390 mock_process_vio_numa_nodes
.assert_called_once_with(
5391 2, {"some-key": "some-value", "hw:numa_nodes": "2"}
5394 _call_mock_process_numa_paired_threads
[0].args
,
5396 {"id": 0, "paired-threads": 2},
5398 "hw:cpu_sockets": "2",
5399 "hw:numa_nodes": "2",
5400 "some-key": "some-value",
5405 _call_mock_process_numa_paired_threads
[1].args
,
5407 {"id": 1, "paired-threads": 2},
5409 "hw:cpu_sockets": "2",
5410 "hw:numa_nodes": "2",
5411 "some-key": "some-value",
5415 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5417 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5418 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5419 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5422 "process_numa_paired_threads",
5423 new_callable
=CopyingMock(),
5425 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5426 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5427 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_openstack(
5429 mock_process_numa_threads
,
5430 mock_process_numa_cores
,
5431 mock_process_numa_paired_threads
,
5432 mock_process_numa_vcpu
,
5433 mock_process_numa_memory
,
5434 mock_process_vio_numa_nodes
,
5436 """Process numa parameters, id, cores exist, vim type is openstack.
5437 vcpus calculation according to cores in numa.
5439 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5441 updated_extra_specs
= {"hw:numa_nodes": "2", "hw:cpu_sockets": "2"}
5442 expected_extra_specs
= {
5443 "hw:numa_nodes": "2",
5444 "hw:cpu_sockets": "2",
5445 "hw:cpu_cores": "3",
5447 self
.vimconn
.vim_type
= "openstack"
5448 mock_process_numa_cores
.side_effect
= [1, 2]
5449 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5451 check_if_assert_not_called(
5452 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5454 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5455 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5456 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5457 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5459 _call_mock_process_numa_cores
[0].args
,
5460 ({"id": 0, "cores": 1}, updated_extra_specs
),
5463 _call_mock_process_numa_cores
[1].args
,
5464 ({"id": 1, "cores": 2}, updated_extra_specs
),
5466 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5468 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5469 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5470 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5473 "process_numa_paired_threads",
5474 new_callable
=CopyingMock(),
5476 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5477 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5478 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_vio(
5480 mock_process_numa_threads
,
5481 mock_process_numa_cores
,
5482 mock_process_numa_paired_threads
,
5483 mock_process_numa_vcpu
,
5484 mock_process_numa_memory
,
5485 mock_process_vio_numa_nodes
,
5487 """Process numa parameters, id, cores exist, vim type is VIO.
5488 vcpus calculation according to cores in numa.
5490 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5492 expected_extra_specs
= {
5493 "hw:cpu_cores": "3",
5494 "hw:cpu_sockets": "2",
5495 "hw:numa_nodes": "2",
5497 self
.vimconn
.vim_type
= "VIO"
5498 mock_process_numa_cores
.side_effect
= [1, 2]
5499 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5500 check_if_assert_not_called(
5501 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5503 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5504 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5505 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5506 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5507 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5509 _call_mock_process_numa_cores
[0].args
,
5511 {"id": 0, "cores": 1},
5513 "hw:cpu_sockets": "2",
5514 "hw:numa_nodes": "2",
5519 _call_mock_process_numa_cores
[1].args
,
5521 {"id": 1, "cores": 2},
5523 "hw:cpu_sockets": "2",
5524 "hw:numa_nodes": "2",
5528 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5530 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5531 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5532 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5535 "process_numa_paired_threads",
5536 new_callable
=CopyingMock(),
5538 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5539 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5540 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_vio(
5542 mock_process_numa_threads
,
5543 mock_process_numa_cores
,
5544 mock_process_numa_paired_threads
,
5545 mock_process_numa_vcpu
,
5546 mock_process_numa_memory
,
5547 mock_process_vio_numa_nodes
,
5549 """Process numa parameters, memory, vcpu, thread exist, vim type is VIO,
5550 vcpus calculation according threads in numa, there are not numa ids.
5553 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5554 {"memory": 2, "vcpu": [2]},
5557 expected_extra_specs
= {
5558 "hw:numa_nodes": "2",
5559 "hw:cpu_sockets": "2",
5560 "hw:cpu_threads": "3",
5562 self
.vimconn
.vim_type
= "VIO"
5563 mock_process_numa_threads
.return_value
= 3
5564 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5565 check_if_assert_not_called(
5567 mock_process_numa_memory
,
5568 mock_process_numa_vcpu
,
5569 mock_process_numa_cores
,
5570 mock_process_numa_paired_threads
,
5573 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5574 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5575 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5577 _call_mock_process_numa_threads
[0].args
,
5579 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5581 "hw:cpu_sockets": "2",
5582 "hw:numa_nodes": "2",
5586 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5588 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5589 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5590 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5593 "process_numa_paired_threads",
5594 new_callable
=CopyingMock(autospec
=True),
5596 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5597 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5598 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_openstack(
5600 mock_process_numa_threads
,
5601 mock_process_numa_cores
,
5602 mock_process_numa_paired_threads
,
5603 mock_process_numa_vcpu
,
5604 mock_process_numa_memory
,
5605 mock_process_vio_numa_nodes
,
5607 """Process numa parameters, memory, vcpu, thread exist, vim type is openstack,
5608 vcpus calculation according threads in numa, there are not numa ids.
5611 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5612 {"memory": 2, "vcpu": [2]},
5615 expected_extra_specs
= {
5616 "hw:numa_nodes": "2",
5617 "hw:cpu_sockets": "2",
5618 "hw:cpu_threads": "3",
5620 self
.vimconn
.vim_type
= "openstack"
5621 mock_process_numa_threads
.return_value
= 3
5622 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5624 check_if_assert_not_called(
5626 mock_process_numa_memory
,
5627 mock_process_numa_vcpu
,
5628 mock_process_numa_cores
,
5629 mock_process_numa_paired_threads
,
5630 mock_process_vio_numa_nodes
,
5633 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5634 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5636 _call_mock_process_numa_threads
[0].args
,
5638 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5639 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5642 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5644 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5645 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5646 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5649 "process_numa_paired_threads",
5650 new_callable
=CopyingMock(),
5652 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5653 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5654 def test_process_numa_parameters_of_flavor_empty_numas_list_type_vio(
5656 mock_process_numa_threads
,
5657 mock_process_numa_cores
,
5658 mock_process_numa_paired_threads
,
5659 mock_process_numa_vcpu
,
5660 mock_process_numa_memory
,
5661 mock_process_vio_numa_nodes
,
5663 """Numa list is empty, vim type is VIO."""
5666 expected_extra_specs
= {"hw:numa_nodes": "0"}
5667 self
.vimconn
.vim_type
= "VIO"
5668 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5669 check_if_assert_not_called(
5671 mock_process_numa_memory
,
5672 mock_process_numa_vcpu
,
5673 mock_process_numa_cores
,
5674 mock_process_numa_paired_threads
,
5675 mock_process_numa_threads
,
5678 mock_process_vio_numa_nodes
.assert_called_once_with(0, {"hw:numa_nodes": "0"})
5679 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5681 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5682 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5683 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5686 "process_numa_paired_threads",
5687 new_callable
=CopyingMock(),
5689 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5690 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5691 def test_process_numa_parameters_of_flavor_empty_numas_list_type_openstack(
5693 mock_process_numa_threads
,
5694 mock_process_numa_cores
,
5695 mock_process_numa_paired_threads
,
5696 mock_process_numa_vcpu
,
5697 mock_process_numa_memory
,
5698 mock_process_vio_numa_nodes
,
5700 """Numa list is empty, vim type is openstack."""
5703 expected_extra_specs
= {"hw:numa_nodes": "0"}
5704 self
.vimconn
.vim_type
= "openstack"
5705 mock_process_numa_threads
.return_value
= None
5706 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5708 check_if_assert_not_called(
5710 mock_process_numa_memory
,
5711 mock_process_numa_vcpu
,
5712 mock_process_numa_cores
,
5713 mock_process_numa_paired_threads
,
5714 mock_process_numa_threads
,
5715 mock_process_vio_numa_nodes
,
5718 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5720 def test_process_numa_memory_empty_extra_spec(self
):
5721 numa
= {"memory": 2, "vcpu": [2]}
5724 expected_extra_spec
= {"hw:numa_mem.2": 2048}
5725 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5726 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5728 def test_process_numa_memory_not_exist(self
):
5729 numa
= {"vcpu": [2]}
5731 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5732 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5733 self
.assertDictEqual(extra_specs
, {"vmware:latency_sensitivity_level": "high"})
5735 def test_process_numa_memory_node_id_is_none(self
):
5736 numa
= {"memory": 2, "vcpu": [2]}
5739 expected_extra_spec
= {"hw:numa_mem.None": 2048}
5740 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5741 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5743 def test_process_numa_vcpu_empty_extra_spec(self
):
5744 numa
= {"vcpu": [2]}
5747 expected_extra_spec
= {"hw:numa_cpus.0": "2"}
5748 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5749 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5751 def test_process_numa_vcpu_not_exist(self
):
5752 numa
= {"memory": 2}
5754 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5755 expected_extra_spec
= {"vmware:latency_sensitivity_level": "high"}
5756 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5757 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5759 def test_process_numa_vcpu_empty_node_id(self
):
5760 numa
= {"vcpu": [2]}
5763 expected_extra_spec
= {"hw:numa_cpus.": "2"}
5764 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5765 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5767 def test_process_numa_vcpu_empty_numa_dict(self
):
5771 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5772 self
.assertDictEqual(extra_specs
, {})
5774 def test_process_numa_vcpu_str_node_id(self
):
5775 numa
= {"vcpu": [2]}
5778 expected_extra_spec
= {"hw:numa_cpus.12": "2"}
5779 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5780 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5782 def test_process_numa_paired_threads_empty_extra_spec(self
):
5783 numa
= {"id": 0, "paired-threads": 3}
5785 expected_extra_spec
= {
5786 "hw:cpu_thread_policy": "require",
5787 "hw:cpu_policy": "dedicated",
5789 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5790 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5791 self
.assertEqual(result
, 6)
5793 def test_process_numa_paired_threads_empty_numa(self
):
5796 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5797 self
.assertDictEqual(extra_specs
, {})
5798 self
.assertEqual(result
, None)
5800 def test_process_numa_paired_threads_not_exist(self
):
5801 numa
= {"vcpu": [2]}
5803 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5804 self
.assertDictEqual(extra_specs
, {})
5805 self
.assertEqual(result
, None)
5807 def test_process_numa_paired_threads_str_thread_num(self
):
5808 numa
= {"id": 0, "paired-threads": "3"}
5810 expected_extra_spec
= {
5811 "hw:cpu_thread_policy": "require",
5812 "hw:cpu_policy": "dedicated",
5814 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5815 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5816 self
.assertEqual(result
, "33")
5818 def test_process_numa_paired_threads_none_thread_num(self
):
5819 numa
= {"id": 0, "paired-threads": None}
5821 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5822 self
.assertDictEqual(extra_specs
, {})
5823 self
.assertEqual(result
, None)
5825 def test_process_numa_cores_empty_extra_spec(self
):
5826 numa
= {"id": 0, "cores": 1}
5828 expected_extra_spec
= {
5829 "hw:cpu_policy": "dedicated",
5830 "hw:cpu_thread_policy": "isolate",
5832 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5833 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5834 self
.assertEqual(result
, 1)
5836 def test_process_numa_cores_not_exist(self
):
5837 numa
= {"id": 0, "paired-threads": 3}
5839 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5840 self
.assertDictEqual(extra_specs
, {})
5841 self
.assertEqual(result
, None)
5843 def test_process_numa_cores_empty_numa(self
):
5845 extra_specs
= expected_extra_spec
= {"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
, None)
5850 def test_process_numa_cores_none_core_num(self
):
5851 numa
= {"memory": 1, "cores": None}
5853 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5854 self
.assertDictEqual(extra_specs
, {})
5855 self
.assertEqual(result
, None)
5857 def test_process_numa_cores_string_core_num(self
):
5858 numa
= {"id": 0, "cores": "1"}
5859 extra_specs
= {"some-key": "some-val"}
5860 expected_extra_spec
= {
5861 "hw:cpu_policy": "dedicated",
5862 "hw:cpu_thread_policy": "isolate",
5863 "some-key": "some-val",
5865 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5866 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5867 self
.assertEqual(result
, "1")
5869 def test_process_numa_cores_float_core_num(self
):
5870 numa
= {"memory": 2, "cores": 10.03}
5871 extra_specs
= {"some-key": "some-val"}
5872 expected_extra_spec
= {
5873 "hw:cpu_policy": "dedicated",
5874 "hw:cpu_thread_policy": "isolate",
5875 "some-key": "some-val",
5877 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5878 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5879 self
.assertEqual(result
, 10.03)
5881 def test_process_numa_threads_empty_extra_spec_int_thread_num(self
):
5882 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3}
5884 expected_extra_spec
= {
5885 "hw:cpu_policy": "dedicated",
5886 "hw:cpu_thread_policy": "prefer",
5888 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5889 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5890 self
.assertEqual(result
, 3)
5892 def test_process_numa_threads_empty_numa(self
):
5894 extra_specs
= {"some-key": "some-val"}
5895 expected_extra_spec
= {"some-key": "some-val"}
5896 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5897 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5898 self
.assertEqual(result
, None)
5900 def test_process_numa_threads_not_exist(self
):
5901 numa
= {"memory": 1}
5902 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5903 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5904 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5905 self
.assertEqual(result
, None)
5907 def test_process_numa_threads_str_thread_num(self
):
5908 numa
= {"vcpu": [1, 3], "threads": "3"}
5910 expected_extra_spec
= {
5911 "hw:cpu_policy": "dedicated",
5912 "hw:cpu_thread_policy": "prefer",
5914 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5915 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5916 self
.assertEqual(result
, "3")
5918 def test_process_numa_threads_none_thread_num(self
):
5919 numa
= {"vcpu": [1, 3], "threads": None}
5921 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5922 self
.assertDictEqual(extra_specs
, {})
5923 self
.assertEqual(result
, None)
5925 def test_process_numa_threads_float_thread_num(self
):
5926 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3.3}
5927 extra_specs
= {"some-key": "some-val"}
5928 expected_extra_spec
= {
5929 "hw:cpu_policy": "dedicated",
5930 "hw:cpu_thread_policy": "prefer",
5931 "some-key": "some-val",
5933 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5934 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5935 self
.assertEqual(result
, 3.3)
5937 def test_change_the_flavor_name_not_existing_name(self
):
5938 """Flavor name does not exist in Openstack flavor list."""
5939 self
.flavor1
.name
= "sample-flavor-3"
5940 self
.flavor2
.name
= "other-flavor-4"
5941 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5942 name
= "other-flavor-3"
5944 flavor_data
= {"name": "other-flavor"}
5945 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5946 self
.assertEqual(result
, name
)
5947 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5948 # Checking whether name_suffix changed or not.
5949 self
.assertEqual(name_suffix
, 3)
5951 def test_change_the_flavor_name_existing_name(self
):
5952 """Flavor name exists in Openstack flavor list."""
5953 self
.flavor1
.name
= "other-flavor-6"
5954 self
.flavor2
.name
= "other-flavor-3"
5955 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5956 name
= "other-flavor-3"
5958 flavor_data
= {"name": "other-flavor"}
5959 expected_result
= "other-flavor-7"
5960 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5961 self
.assertEqual(result
, expected_result
)
5962 # Checking whether name_suffix changed or not.
5963 self
.assertEqual(name_suffix
, 5)
5964 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5966 def test_change_the_flavor_name_flavor_data_does_not_have_name(self
):
5967 """Flavor data does not have name."""
5968 self
.flavor1
.name
= "other-flavor-6"
5969 self
.flavor2
.name
= "other-flavor-3"
5970 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5971 name
= "other-flavor-3"
5974 with self
.assertRaises(KeyError):
5975 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5976 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5977 # Checking whether name_suffix changed or not.
5978 self
.assertEqual(name_suffix
, 5)
5980 def test_change_the_flavor_name_invalid_name_suffix(self
):
5981 """Name suffix is invalid."""
5982 self
.flavor1
.name
= "other-flavor-6"
5983 self
.flavor2
.name
= "other-flavor-3"
5984 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5985 name
= "other-flavor-3"
5987 flavor_data
= {"name": "other-flavor"}
5988 with self
.assertRaises(TypeError):
5989 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5990 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5991 # Checking whether name_suffix changed or not.
5992 self
.assertEqual(name_suffix
, "a")
5994 def test_change_the_flavor_name_given_name_is_empty(self
):
5995 """Given name is empty string."""
5996 self
.flavor1
.name
= "other-flavor-6"
5997 self
.flavor2
.name
= "other-flavor-3"
5998 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6001 flavor_data
= {"name": "other-flavor"}
6002 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6003 self
.assertEqual(result
, "")
6004 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6005 # Checking whether name_suffix increased or not.
6006 self
.assertEqual(name_suffix
, 3)
6008 def test_change_the_flavor_name_given_name_is_none(self
):
6009 """Given name is None."""
6010 self
.flavor1
.name
= "other-flavor-6"
6011 self
.flavor2
.name
= "other-flavor-3"
6012 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6015 flavor_data
= {"name": "other-flavor"}
6016 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6017 self
.assertEqual(result
, None)
6018 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6019 # Checking whether name_suffix increased or not.
6020 self
.assertEqual(name_suffix
, 6)
6022 def test_change_the_flavor_name_empty_nova_flavor_list(self
):
6023 """Nova flavor list is empty."""
6024 self
.vimconn
.nova
.flavors
.list.return_value
= []
6025 name
= "other-flavor-3"
6027 flavor_data
= {"name": "other-flavor"}
6028 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6029 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6030 self
.assertEqual(result
, name
)
6031 # Checking whether name_suffix increased or not.
6032 self
.assertEqual(name_suffix
, 5)
6036 "_process_numa_parameters_of_flavor",
6037 new_callable
=CopyingMock(),
6039 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6040 def test_process_extended_config_of_flavor_with_numa_cpu_mem_vif_disk_quota(
6041 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6043 """Process extended config, extended has numas, cpu, mem, vif and disk-io quota."""
6045 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6046 {"memory": 2, "vcpu": [2]},
6050 "cpu-quota": {"limit": 3},
6051 "mem-quota": {"limit": 1},
6052 "vif-quota": {"limit": 10},
6053 "disk-io-quota": {"limit": 50},
6054 "mempage-size": "LARGE",
6057 expected_extra_specs
= {
6058 "hw:mem_page_size": "large",
6060 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6062 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6063 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6064 self
.assertEqual(extra_specs
, expected_extra_specs
)
6068 "_process_numa_parameters_of_flavor",
6069 new_callable
=CopyingMock(),
6071 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6072 def test_process_extended_config_of_flavor_with_numa_wrong_disk_quota(
6073 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6075 """Process extended config, extended has wrong disk quota key."""
6077 {"memory": 1, "threads": 3},
6078 {"memory": 2, "vcpu": [2]},
6082 "disk-quota": {"limit": 50},
6083 "mempage-size": "PREFER_LARGE",
6086 expected_extra_specs
= {
6087 "hw:mem_page_size": "any",
6089 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6090 mock_process_resource_quota
.assert_not_called()
6091 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6092 self
.assertEqual(extra_specs
, expected_extra_specs
)
6096 "_process_numa_parameters_of_flavor",
6097 new_callable
=CopyingMock(),
6099 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6100 def test_process_extended_config_of_flavor_without_numa_cpu_mem_vif_disk_quota(
6101 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6103 """Process extended config, extended has cpu, mem, vif and disk-io quota but not numas."""
6105 "cpu-quota": {"limit": 3},
6106 "mem-quota": {"limit": 1},
6107 "vif-quota": {"limit": 10},
6108 "disk-io-quota": {"limit": 50},
6109 "mempage-size": "SMALL",
6112 expected_extra_specs
= {
6113 "hw:mem_page_size": "small",
6115 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6116 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6117 mock_process_numa_parameters_of_flavor
.assert_not_called()
6118 self
.assertEqual(extra_specs
, expected_extra_specs
)
6122 "_process_numa_parameters_of_flavor",
6123 new_callable
=CopyingMock(),
6125 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6126 def test_process_extended_config_of_flavor_with_numa_with_cpu_pinning_mem_policy(
6127 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6129 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy."""
6132 {"memory": 2, "vcpu": [2]},
6136 "cpu-quota": {"limit": 3},
6137 "mem-quota": {"limit": 1},
6138 "mempage-size": "LARGE",
6139 "cpu-pinning-policy": "DEDICATED",
6140 "mem-policy": "STRICT",
6143 expected_extra_specs
= {
6144 "hw:mem_page_size": "large",
6145 "hw:cpu_policy": "dedicated",
6146 "hw:numa_mempolicy": "strict",
6148 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6149 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6150 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6151 self
.assertEqual(extra_specs
, expected_extra_specs
)
6155 "_process_numa_parameters_of_flavor",
6156 new_callable
=CopyingMock(),
6158 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6159 def test_process_extended_config_of_flavor_without_numa_with_cpu_pinning_mem_policy(
6160 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6162 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy but not numas."""
6164 "cpu-quota": {"limit": 3},
6165 "mem-quota": {"limit": 1},
6166 "mempage-size": "LARGE",
6167 "cpu-pinning-policy": "DEDICATED",
6168 "mem-policy": "STRICT",
6171 expected_extra_specs
= {
6172 "hw:mem_page_size": "large",
6173 "hw:cpu_policy": "dedicated",
6174 "hw:numa_mempolicy": "strict",
6176 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6177 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6178 mock_process_numa_parameters_of_flavor
.assert_not_called()
6179 self
.assertEqual(extra_specs
, expected_extra_specs
)
6183 "_process_numa_parameters_of_flavor",
6184 new_callable
=CopyingMock(),
6186 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6187 def test_process_extended_config_of_flavor_without_numa_with_wrong_mempage_size(
6188 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6190 """Process extended config, extended has wrong mempage-size without numas."""
6192 "cpu-quota": {"limit": 3},
6193 "mem-quota": {"limit": 1},
6194 "mempage-size": "SIZE_2GB",
6195 "cpu-pinning-policy": "DEDICATED",
6196 "mem-policy": "STRICT",
6200 expected_extra_specs
= {
6201 "hw:cpu_policy": "dedicated",
6202 "hw:numa_mempolicy": "strict",
6204 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6205 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6206 mock_process_numa_parameters_of_flavor
.assert_not_called()
6207 self
.assertEqual(extra_specs
, expected_extra_specs
)
6211 "_process_numa_parameters_of_flavor",
6212 new_callable
=CopyingMock(),
6214 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6215 def test_process_extended_config_of_flavor_with_numa_with_wrong_mempage_size(
6216 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6218 """Process extended config, extended has wrong mempage-size with numas."""
6221 {"memory": 2, "vcpu": [2]},
6225 "cpu-quota": {"limit": 3},
6226 "mem-quota": {"limit": 1},
6227 "mempage-size": "SIZE_2GB",
6228 "cpu-pinning-policy": "DEDICATED",
6229 "mem-policy": "STRICT",
6232 expected_extra_specs
= {
6233 "hw:cpu_policy": "dedicated",
6234 "hw:numa_mempolicy": "strict",
6236 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6237 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6238 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6239 self
.assertEqual(extra_specs
, expected_extra_specs
)
6243 "_process_numa_parameters_of_flavor",
6244 new_callable
=CopyingMock(),
6246 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6247 def test_process_extended_config_of_flavor_none_vcpus(
6248 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6250 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6253 {"memory": 2, "vcpu": [2]},
6257 "cpu-quota": {"limit": 3},
6258 "mem-quota": {"limit": 1},
6259 "mempage-size": "SIZE_2GB",
6260 "cpu-pinning-policy": "DEDICATED",
6261 "mem-policy": "STRICT",
6264 expected_extra_specs
= {
6265 "hw:cpu_policy": "dedicated",
6266 "hw:numa_mempolicy": "strict",
6268 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6269 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6270 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6271 self
.assertEqual(extra_specs
, expected_extra_specs
)
6275 "_process_numa_parameters_of_flavor",
6276 new_callable
=CopyingMock(),
6278 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6279 def test_process_extended_config_of_flavor_none_vcpus_without_numas(
6280 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6282 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6284 "cpu-quota": {"limit": 3},
6285 "mem-quota": {"limit": 1},
6286 "mempage-size": "SIZE_2GB",
6287 "cpu-pinning-policy": "DEDICATED",
6288 "mem-policy": "STRICT",
6290 extra_specs
= {"some-key": "some-val"}
6291 expected_extra_specs
= {
6292 "hw:cpu_policy": "dedicated",
6293 "hw:numa_mempolicy": "strict",
6294 "some-key": "some-val",
6296 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6297 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6298 mock_process_numa_parameters_of_flavor
.assert_not_called()
6299 self
.assertEqual(extra_specs
, expected_extra_specs
)
6303 "_process_numa_parameters_of_flavor",
6304 new_callable
=CopyingMock(),
6306 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6307 def test_process_extended_config_of_flavor_wrong_cpu_pinning_mem_policy_empty_vcpus(
6308 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6310 """Process extended config, extended has wrong cpu-pinning and mem-policy keys."""
6313 {"memory": 2, "vcpu": [2]},
6317 "cpu-quota": {"limit": 3},
6318 "mem-quota": {"limit": 1},
6319 "mempage-size": "SIZE_2GB",
6320 "cpu-pinning-pol": "DEDICATED",
6321 "mem-pol": "STRICT",
6324 expected_extra_specs
= {}
6325 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6326 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6327 mock_process_numa_parameters_of_flavor
.assert_called_once_with(
6330 self
.assertEqual(extra_specs
, expected_extra_specs
)
6334 "_process_numa_parameters_of_flavor",
6335 new_callable
=CopyingMock(),
6337 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6338 def test_process_extended_config_of_flavor_empty_extended(
6339 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6341 """Process extended config, extended is empty."""
6344 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6345 check_if_assert_not_called(
6346 [mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
]
6348 self
.assertEqual(extra_specs
, {})
6350 def test_get_flavor_details_empty_flavor_data(self
):
6352 expected_result
= (64, 1, {}, None)
6353 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6354 self
.assertEqual(result
, expected_result
)
6356 def test_get_flavor_details_flavor_data_has_ram_vcpus_extended(self
):
6361 "some-key": "some-val",
6364 expected_result
= (32, 3, {}, {"some-key": "some-val"})
6365 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6366 self
.assertEqual(result
, expected_result
)
6368 def test_get_flavor_details_flavor_data_is_none(self
):
6370 with self
.assertRaises(AttributeError):
6371 self
.vimconn
._get
_flavor
_details
(flavor_data
)
6373 def test_get_flavor_details_flavor_data_has_only_extended(self
):
6376 "some-key": "some-val",
6379 expected_result
= (64, 1, {}, {"some-key": "some-val"})
6380 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6381 self
.assertEqual(result
, expected_result
)
6383 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6386 "_process_extended_config_of_flavor",
6387 new_callable
=CopyingMock(),
6389 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6390 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6391 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6392 def test_new_flavor_with_extended_with_extra_specs(
6394 mock_format_exception
,
6395 mock_reload_connection
,
6396 mock_change_flavor_name
,
6397 mock_extended_config_of_flavor
,
6398 mock_get_flavor_details
,
6400 """Create new flavor with using extended parameters and extra specs."""
6403 mock_change_flavor_name
.return_value
= name1
6404 mock_get_flavor_details
.return_value
= (
6407 {"some-key": "some-value"},
6410 expected_result
= self
.new_flavor
.id
6411 result
= self
.vimconn
.new_flavor(flavor_data
)
6412 self
.assertEqual(result
, expected_result
)
6413 mock_reload_connection
.assert_called_once()
6414 self
.new_flavor
.set_keys
.assert_called_once()
6415 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6416 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6417 mock_extended_config_of_flavor
.assert_called_once_with(
6418 extended
, {"some-key": "some-value"}
6420 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6421 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6423 mock_format_exception
.assert_not_called()
6425 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6428 "_process_extended_config_of_flavor",
6429 new_callable
=CopyingMock(),
6431 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6432 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6433 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6434 def test_new_flavor_with_extended_without_extra_specs(
6436 mock_format_exception
,
6437 mock_reload_connection
,
6438 mock_change_flavor_name
,
6439 mock_extended_config_of_flavor
,
6440 mock_get_flavor_details
,
6442 """Create new flavor with using extended parameters without extra specs."""
6445 mock_change_flavor_name
.return_value
= name1
6446 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6447 expected_result
= self
.new_flavor
.id
6448 result
= self
.vimconn
.new_flavor(flavor_data
)
6449 self
.assertEqual(result
, expected_result
)
6450 mock_reload_connection
.assert_called_once()
6451 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6452 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6453 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6454 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6455 name
=name1
, ram
=3, vcpus
=vcpus
, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6457 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6459 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6462 "_process_extended_config_of_flavor",
6463 new_callable
=CopyingMock(),
6465 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6466 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6467 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6468 def test_new_flavor_change_name_if_used_false_with_extended(
6470 mock_format_exception
,
6471 mock_reload_connection
,
6472 mock_change_flavor_name
,
6473 mock_extended_config_of_flavor
,
6474 mock_get_flavor_details
,
6476 """Create new flavor, change_name_if_used_false, there is extended."""
6478 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6479 expected_result
= self
.new_flavor
.id
6480 result
= self
.vimconn
.new_flavor(flavor_data
, False)
6481 self
.assertEqual(result
, expected_result
)
6482 mock_reload_connection
.assert_called_once()
6483 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6484 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6485 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6486 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6488 check_if_assert_not_called(
6489 [mock_change_flavor_name
, mock_format_exception
, self
.new_flavor
.set_keys
]
6492 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6495 "_process_extended_config_of_flavor",
6496 new_callable
=CopyingMock(),
6498 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6499 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6500 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6501 def test_new_flavor_change_name_if_used_true_without_extended(
6503 mock_format_exception
,
6504 mock_reload_connection
,
6505 mock_change_flavor_name
,
6506 mock_extended_config_of_flavor
,
6507 mock_get_flavor_details
,
6509 """Create new flavor without extended parameters."""
6511 mock_change_flavor_name
.return_value
= name1
6512 expected_result
= self
.new_flavor
.id
6513 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6514 result
= self
.vimconn
.new_flavor(flavor_data2
)
6515 self
.assertEqual(result
, expected_result
)
6516 mock_reload_connection
.assert_called_once()
6517 mock_change_flavor_name
.assert_called_once_with(
6518 name1
, name_suffix
, flavor_data2
6520 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6521 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6522 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6524 check_if_assert_not_called(
6526 self
.new_flavor
.set_keys
,
6527 mock_extended_config_of_flavor
,
6528 mock_format_exception
,
6532 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6535 "_process_extended_config_of_flavor",
6536 new_callable
=CopyingMock(),
6538 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6539 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6540 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6541 def test_new_flavor_reload_connection_exception(
6543 mock_format_exception
,
6544 mock_reload_connection
,
6545 mock_change_flavor_name
,
6546 mock_extended_config_of_flavor
,
6547 mock_get_flavor_details
,
6549 """Create new flavor, reload connection exception occurred."""
6550 error_msg
= "Can not connect to client APIs."
6551 error
= nvExceptions
.ClientException(error_msg
)
6552 mock_change_flavor_name
.return_value
= name1
6553 mock_reload_connection
.side_effect
= error
6554 with self
.assertRaises(Exception) as err
:
6555 self
.vimconn
.new_flavor(flavor_data2
)
6556 self
.assertEqual(str(err
.exception
), "Can not connect to client APIs.")
6557 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6558 call_mock_format_exception
= mock_format_exception
.call_args
6560 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6562 check_if_assert_not_called(
6564 mock_change_flavor_name
,
6565 mock_get_flavor_details
,
6566 mock_extended_config_of_flavor
,
6567 self
.vimconn
.nova
.flavors
.create
,
6571 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6574 "_process_extended_config_of_flavor",
6575 new_callable
=CopyingMock(autospec
=True),
6577 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6578 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6579 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6580 def test_new_flavor_flavor_data_without_name(
6582 mock_format_exception
,
6583 mock_reload_connection
,
6584 mock_change_flavor_name
,
6585 mock_extended_config_of_flavor
,
6586 mock_get_flavor_details
,
6588 """Create new flavor, flavor data does not have name."""
6595 self
.vimconn
.new_flavor(flavor_data3
)
6596 mock_format_exception
.assert_called_once()
6597 call_mock_format_exception
= mock_format_exception
.call_args
6599 str(call_mock_format_exception
[0][0]), str(KeyError(error_msg
))
6601 check_if_assert_not_called(
6603 mock_reload_connection
,
6604 mock_change_flavor_name
,
6605 mock_get_flavor_details
,
6606 mock_extended_config_of_flavor
,
6607 self
.vimconn
.nova
.flavors
.create
,
6611 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6614 "_process_extended_config_of_flavor",
6615 new_callable
=CopyingMock(),
6617 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6618 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6619 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6620 def test_new_flavor_change_flavor_name_has_extended_conflict_exception_recovered_in_retry(
6622 mock_format_exception
,
6623 mock_reload_connection
,
6624 mock_change_flavor_name
,
6625 mock_extended_config_of_flavor
,
6626 mock_get_flavor_details
,
6628 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is extended config."""
6630 error_msg
= "Conflict has occurred while creating flavor name."
6631 error2
= nvExceptions
.Conflict(error_msg
)
6632 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6633 expected_result
= self
.new_flavor
.id
6634 mock_get_flavor_details
.return_value
= (3, 8, {}, extended
)
6635 result
= self
.vimconn
.new_flavor(flavor_data2
)
6636 self
.assertEqual(result
, expected_result
)
6637 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6638 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6639 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6640 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6641 self
.assertEqual(mock_extended_config_of_flavor
.call_count
, 1)
6642 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6643 name
="sample-flavor-3",
6651 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6653 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6656 "_process_extended_config_of_flavor",
6657 new_callable
=CopyingMock(),
6659 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6660 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6661 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6662 def test_new_flavor_change_flavor_name_without_extended_conflict_exception_recovered_in_retry(
6664 mock_format_exception
,
6665 mock_reload_connection
,
6666 mock_change_flavor_name
,
6667 mock_extended_config_of_flavor
,
6668 mock_get_flavor_details
,
6670 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is not extended config."""
6672 error2
= nvExceptions
.Conflict(
6673 "Conflict has occurred while creating flavor name."
6675 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6676 expected_result
= self
.new_flavor
.id
6677 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6678 result
= self
.vimconn
.new_flavor(flavor_data2
)
6679 self
.assertEqual(result
, expected_result
)
6680 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6681 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6682 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6683 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6684 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6685 name
="sample-flavor-3",
6693 check_if_assert_not_called(
6695 self
.new_flavor
.set_keys
,
6696 mock_extended_config_of_flavor
,
6697 mock_format_exception
,
6701 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6704 "_process_extended_config_of_flavor",
6705 new_callable
=CopyingMock(),
6707 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6708 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6709 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6710 def test_new_flavor_change_flavor_name_conflict_exception_change_name_if_used_false(
6712 mock_format_exception
,
6713 mock_reload_connection
,
6714 mock_change_flavor_name
,
6715 mock_extended_config_of_flavor
,
6716 mock_get_flavor_details
,
6718 """Create new flavor, nvExceptions.Conflict occurred,
6719 change_name_if_used is false."""
6720 change_name_if_used
= False
6721 error_msg
= "Conflict has occurred while creating flavor name."
6722 error2
= nvExceptions
.Conflict(error_msg
)
6723 mock_get_flavor_details
.return_value
= (4, 8, {}, None)
6724 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6725 with self
.assertRaises(Exception) as err
:
6726 self
.vimconn
.new_flavor(flavor_data2
, change_name_if_used
)
6727 self
.assertEqual(str(err
.exception
), error_msg
)
6728 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6729 self
.vimconn
.nova
.flavors
.create
.assert_called_with(
6730 name
="sample-flavor",
6738 self
.assertEqual(mock_get_flavor_details
.call_count
, 3)
6739 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6740 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6741 check_if_assert_not_called(
6742 [mock_change_flavor_name
, mock_extended_config_of_flavor
]
6744 _call_mock_format_exception
= mock_format_exception
.call_args
6746 str(_call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6748 self
.assertEqual(mock_format_exception
.call_count
, 3)
6750 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6753 "_process_extended_config_of_flavor",
6754 new_callable
=CopyingMock(),
6756 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6757 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6758 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6759 def test_new_flavor_client_exception_occurred_change_name_if_used_true(
6761 mock_format_exception
,
6762 mock_reload_connection
,
6763 mock_change_flavor_name
,
6764 mock_extended_config_of_flavor
,
6765 mock_get_flavor_details
,
6767 """Create new flavor, nvExceptions.ClientException occurred,
6768 change_name_if_used is true."""
6769 error_msg
= "Connection failed."
6770 error2
= nvExceptions
.ClientException(error_msg
)
6771 mock_change_flavor_name
.side_effect
= [
6776 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6777 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6778 with self
.assertRaises(Exception) as err
:
6779 self
.vimconn
.new_flavor(flavor_data2
)
6781 str(err
.exception
), "Conflict has occurred while creating flavor name."
6783 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6784 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 1)
6785 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6787 _call_mock_nova_create_flavor
[0][1],
6790 "name": "sample-flavor-3",
6801 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6802 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6803 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6805 _call_mock_change_flavor
[0][0],
6809 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6812 self
.assertEqual(mock_change_flavor_name
.call_count
, 1)
6813 mock_extended_config_of_flavor
.assert_not_called()
6814 call_mock_format_exception
= mock_format_exception
.call_args
6816 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6818 self
.assertEqual(mock_format_exception
.call_count
, 1)
6820 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6823 "_process_extended_config_of_flavor",
6824 new_callable
=CopyingMock(),
6826 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6827 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6828 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6829 def test_new_flavor_change_flavor_name_conflict_exception_occurred_change_name_if_used_true(
6831 mock_format_exception
,
6832 mock_reload_connection
,
6833 mock_change_flavor_name
,
6834 mock_extended_config_of_flavor
,
6835 mock_get_flavor_details
,
6837 """Create new flavor, nvExceptions.Conflict occurred,
6838 change_name_if_used is true."""
6839 error_msg
= "Conflict has occurred while creating flavor name."
6840 error2
= nvExceptions
.Conflict(error_msg
)
6841 mock_change_flavor_name
.side_effect
= [
6846 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6847 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6848 with self
.assertRaises(Exception) as err
:
6849 self
.vimconn
.new_flavor(flavor_data2
)
6850 self
.assertEqual(str(err
.exception
), error_msg
)
6851 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6852 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6853 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6855 _call_mock_nova_create_flavor
[0][1],
6858 "name": "sample-flavor-3",
6869 _call_mock_nova_create_flavor
[1][1],
6872 "name": "sample-flavor-4",
6883 _call_mock_nova_create_flavor
[2][1],
6886 "name": "sample-flavor-5",
6896 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6897 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6899 _call_mock_change_flavor
[0][0],
6903 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6907 _call_mock_change_flavor
[1][0],
6911 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6915 _call_mock_change_flavor
[2][0],
6919 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6922 self
.assertEqual(mock_change_flavor_name
.call_count
, 3)
6923 mock_extended_config_of_flavor
.assert_not_called()
6924 call_mock_format_exception
= mock_format_exception
.call_args
6926 str(call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6928 self
.assertEqual(mock_format_exception
.call_count
, 1)
6930 def test_process_process_vio_numa_nodes_without_numa_with_extra_spec(self
):
6932 extra_specs
= {"hw:numa_nodes": "0"}
6933 expected_extra_spec
= {
6934 "vmware:latency_sensitivity_level": "high",
6935 "hw:numa_nodes": "0",
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_list_type_numa_nodes_empty_extra_spec(self
):
6941 numa_nodes
= [7, 9, 4]
6943 expected_extra_spec
= {
6944 "vmware:latency_sensitivity_level": "high",
6946 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6947 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6949 def test_process_process_vio_numa_nodes_with_numa_with_extra_spec(self
):
6951 extra_specs
= {"hw:numa_nodes": "5"}
6952 expected_extra_spec
= {
6953 "vmware:latency_sensitivity_level": "high",
6954 "hw:numa_nodes": "5",
6956 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6957 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6959 def test_process_process_vio_numa_nodes_none_numa_nodes(self
):
6961 extra_specs
= {"hw:numa_nodes": "None"}
6962 expected_extra_spec
= {
6963 "vmware:latency_sensitivity_level": "high",
6964 "hw:numa_nodes": "None",
6966 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6967 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6969 def test_process_process_vio_numa_nodes_invalid_type_extra_specs(self
):
6972 with self
.assertRaises(TypeError):
6973 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6976 if __name__
== "__main__":