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("available", "multiattach", "shared-volume", volume_id4
)
1349 self
.vimconn
.cinder
.volumes
.get
.return_value
.id = volume_id4
1350 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1351 self
.vimconn
._prepare
_shared
_volumes
(
1355 block_device_mapping
,
1356 existing_vim_volumes
,
1359 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id4
)
1360 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1362 @patch.object(vimconnector
, "update_block_device_mapping")
1363 def test_prepare_persistent_non_root_volumes_vim_using_volume_id(
1364 self
, mock_update_block_device_mapping
1366 """Existing persistent non root volume with vim_volume_id."""
1367 vm_av_zone
= ["nova"]
1368 base_disk_index
= ord("b")
1369 disk
= {"vim_volume_id": volume_id
}
1370 block_device_mapping
= {}
1371 existing_vim_volumes
= []
1373 expected_block_device_mapping
= {"vdb": volume_id
}
1374 expected_existing_vim_volumes
= [{"id": volume_id
}]
1375 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1379 block_device_mapping
,
1381 existing_vim_volumes
,
1384 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1385 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1386 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1387 mock_update_block_device_mapping
.assert_not_called()
1389 @patch.object(vimconnector
, "update_block_device_mapping")
1390 def test_prepare_persistent_root_volumes_using_vim_id(
1391 self
, mock_update_block_device_mapping
1393 """Existing persistent root volume with vim_id."""
1394 vm_av_zone
= ["nova"]
1395 base_disk_index
= ord("a")
1396 disk
= {"vim_id": volume_id
}
1397 block_device_mapping
= {}
1398 existing_vim_volumes
= []
1400 expected_boot_vol_id
= None
1401 expected_block_device_mapping
= {"vda": volume_id
}
1402 expected_existing_vim_volumes
= [{"id": volume_id
}]
1403 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1408 block_device_mapping
,
1409 existing_vim_volumes
,
1412 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1413 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1414 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1415 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1416 mock_update_block_device_mapping
.assert_not_called()
1418 @patch.object(vimconnector
, "update_block_device_mapping")
1419 def test_prepare_persistent_non_root_volumes_using_vim_id(
1420 self
, mock_update_block_device_mapping
1422 """Existing persistent root volume with vim_id."""
1423 vm_av_zone
= ["nova"]
1424 base_disk_index
= ord("b")
1425 disk
= {"vim_id": volume_id
}
1426 block_device_mapping
= {}
1427 existing_vim_volumes
= []
1430 expected_block_device_mapping
= {"vdb": volume_id
}
1431 expected_existing_vim_volumes
= [{"id": volume_id
}]
1432 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1436 block_device_mapping
,
1438 existing_vim_volumes
,
1442 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
1443 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1444 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
1445 mock_update_block_device_mapping
.assert_not_called()
1447 @patch.object(vimconnector
, "update_block_device_mapping")
1448 def test_prepare_persistent_root_volumes_create(
1449 self
, mock_update_block_device_mapping
1451 """Create persistent root volume."""
1452 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1453 vm_av_zone
= ["nova"]
1454 base_disk_index
= ord("a")
1455 disk
= {"size": 10, "image_id": image_id
}
1456 block_device_mapping
= {}
1457 existing_vim_volumes
= []
1459 expected_boot_vol_id
= volume_id2
1460 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1465 block_device_mapping
,
1466 existing_vim_volumes
,
1469 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1470 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1474 availability_zone
=["nova"],
1476 mock_update_block_device_mapping
.assert_called_once()
1477 _call_mock_update_block_device_mapping
= (
1478 mock_update_block_device_mapping
.call_args_list
1481 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1482 block_device_mapping
,
1485 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1487 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1489 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1492 @patch.object(vimconnector
, "update_block_device_mapping")
1493 def test_prepare_persistent_root_volumes_create_with_keep(
1494 self
, mock_update_block_device_mapping
1496 """Create persistent root volume, disk has keep parameter."""
1497 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1498 vm_av_zone
= ["nova"]
1499 base_disk_index
= ord("a")
1500 disk
= {"size": 10, "image_id": image_id
, "keep": True}
1501 block_device_mapping
= {}
1502 existing_vim_volumes
= []
1504 expected_boot_vol_id
= volume_id2
1505 expected_existing_vim_volumes
= []
1506 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1511 block_device_mapping
,
1512 existing_vim_volumes
,
1515 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
1516 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1517 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1521 availability_zone
=["nova"],
1523 mock_update_block_device_mapping
.assert_called_once()
1524 _call_mock_update_block_device_mapping
= (
1525 mock_update_block_device_mapping
.call_args_list
1528 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1529 block_device_mapping
,
1532 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1534 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1536 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1539 @patch.object(vimconnector
, "update_block_device_mapping")
1540 def test_prepare_persistent_non_root_volumes_create(
1541 self
, mock_update_block_device_mapping
1543 """Create persistent non-root volume."""
1544 self
.vimconn
.cinder
= CopyingMock()
1545 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1546 vm_av_zone
= ["nova"]
1547 base_disk_index
= ord("a")
1549 block_device_mapping
= {}
1550 existing_vim_volumes
= []
1552 expected_existing_vim_volumes
= []
1553 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1557 block_device_mapping
,
1559 existing_vim_volumes
,
1563 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1564 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1565 size
=10, name
="basicvmvda", availability_zone
=["nova"]
1567 mock_update_block_device_mapping
.assert_called_once()
1568 _call_mock_update_block_device_mapping
= (
1569 mock_update_block_device_mapping
.call_args_list
1572 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1573 block_device_mapping
,
1576 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1578 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1580 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1583 @patch.object(vimconnector
, "update_block_device_mapping")
1584 def test_prepare_persistent_non_root_volumes_create_with_keep(
1585 self
, mock_update_block_device_mapping
1587 """Create persistent non-root volume."""
1588 self
.vimconn
.cinder
= CopyingMock()
1589 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
1590 vm_av_zone
= ["nova"]
1591 base_disk_index
= ord("a")
1592 disk
= {"size": 10, "keep": True}
1593 block_device_mapping
= {}
1594 existing_vim_volumes
= []
1596 expected_existing_vim_volumes
= []
1597 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1601 block_device_mapping
,
1603 existing_vim_volumes
,
1607 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
1608 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1609 size
=10, name
="basicvmvda", availability_zone
=["nova"]
1611 mock_update_block_device_mapping
.assert_called_once()
1612 _call_mock_update_block_device_mapping
= (
1613 mock_update_block_device_mapping
.call_args_list
1616 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
1617 block_device_mapping
,
1620 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
1622 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
1624 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
1627 @patch.object(vimconnector
, "update_block_device_mapping")
1628 def test_new_shared_volumes(self
, mock_update_block_device_mapping
):
1629 """Create shared volume."""
1630 self
.vimconn
.cinder
= CopyingMock()
1631 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id4
1632 shared_volume_data
= {"size": 10, "name": "shared-volume"}
1633 self
.vimconn
.cinder
.volumes
.create
.side_effect
= [
1634 Volume("avaible", "multiattach", "shared-volume", volume_id4
)
1636 result
= self
.vimconn
.new_shared_volumes(shared_volume_data
)
1637 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1638 size
=10, name
="shared-volume", volume_type
="multiattach"
1640 self
.assertEqual(result
[0], "shared-volume")
1641 self
.assertEqual(result
[1], volume_id4
)
1643 @patch.object(vimconnector
, "update_block_device_mapping")
1644 def test_prepare_persistent_root_volumes_create_raise_exception(
1645 self
, mock_update_block_device_mapping
1647 """Create persistent root volume raise exception."""
1648 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
1649 vm_av_zone
= ["nova"]
1650 base_disk_index
= ord("a")
1651 disk
= {"size": 10, "image_id": image_id
}
1652 block_device_mapping
= {}
1653 existing_vim_volumes
= []
1656 with self
.assertRaises(Exception):
1657 result
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
1662 block_device_mapping
,
1663 existing_vim_volumes
,
1667 self
.assertEqual(result
, None)
1669 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1673 availability_zone
=["nova"],
1675 self
.assertEqual(existing_vim_volumes
, [])
1676 self
.assertEqual(block_device_mapping
, {})
1677 self
.assertEqual(created_items
, {})
1678 mock_update_block_device_mapping
.assert_not_called()
1680 @patch.object(vimconnector
, "update_block_device_mapping")
1681 def test_prepare_persistent_non_root_volumes_create_raise_exception(
1682 self
, mock_update_block_device_mapping
1684 """Create persistent non-root volume raise exception."""
1685 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
1686 vm_av_zone
= ["nova"]
1687 base_disk_index
= ord("b")
1689 block_device_mapping
= {}
1690 existing_vim_volumes
= []
1693 with self
.assertRaises(Exception):
1694 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
1698 block_device_mapping
,
1700 existing_vim_volumes
,
1704 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
1705 size
=10, name
="basicvmvdb", availability_zone
=["nova"]
1707 self
.assertEqual(existing_vim_volumes
, [])
1708 self
.assertEqual(block_device_mapping
, {})
1709 self
.assertEqual(created_items
, {})
1710 mock_update_block_device_mapping
.assert_not_called()
1712 @patch("time.sleep")
1713 def test_wait_for_created_volumes_availability_volume_status_available(
1716 """Created volume status is available."""
1718 created_items
= {f
"volume:{volume_id2}": True}
1719 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1721 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1722 elapsed_time
, created_items
1724 self
.assertEqual(result
, elapsed_time
)
1725 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1726 mock_sleep
.assert_not_called()
1728 @patch("time.sleep")
1729 def test_wait_for_existing_volumes_availability_volume_status_available(
1732 """Existing volume status is available."""
1734 existing_vim_volumes
= [{"id": volume_id2
}]
1735 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
1737 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1738 elapsed_time
, existing_vim_volumes
1740 self
.assertEqual(result
, elapsed_time
)
1741 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1742 mock_sleep
.assert_not_called()
1744 @patch("time.sleep")
1745 def test_wait_for_created_volumes_availability_status_processing_multiple_volumes(
1748 """Created volume status is processing."""
1751 f
"volume:{volume_id2}": True,
1752 f
"volume:{volume_id3}": True,
1754 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1755 Volume("processing"),
1756 Volume("available"),
1757 Volume("available"),
1760 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1761 elapsed_time
, created_items
1763 self
.assertEqual(result
, 10)
1764 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
1765 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
1766 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
1767 self
.assertEqual(_call_mock_get_volumes
[2][0], (volume_id3
,))
1768 mock_sleep
.assert_called_with(5)
1769 self
.assertEqual(1, mock_sleep
.call_count
)
1771 @patch("time.sleep")
1772 def test_wait_for_existing_volumes_availability_status_processing_multiple_volumes(
1775 """Existing volume status is processing."""
1777 existing_vim_volumes
= [
1779 {"id": "44e0e83-b9uu-4akk-t234-p9cc4811bd4a"},
1781 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1782 Volume("processing"),
1783 Volume("available", "multiattach"),
1784 Volume("available"),
1787 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1788 elapsed_time
, existing_vim_volumes
1790 self
.assertEqual(result
, 10)
1791 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
1792 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
1793 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
1795 _call_mock_get_volumes
[2][0], ("44e0e83-b9uu-4akk-t234-p9cc4811bd4a",)
1797 mock_sleep
.assert_called_with(5)
1798 self
.assertEqual(1, mock_sleep
.call_count
)
1800 @patch("time.sleep")
1801 def test_wait_for_created_volumes_availability_volume_status_processing_timeout(
1804 """Created volume status is processing, elapsed time greater than timeout (1800)."""
1806 created_items
= {f
"volume:{volume_id2}": True}
1807 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1808 Volume("processing"),
1809 Volume("processing"),
1811 with
patch("time.sleep", mock_sleep
):
1812 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1813 elapsed_time
, created_items
1815 self
.assertEqual(result
, 1805)
1816 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1817 mock_sleep
.assert_not_called()
1819 @patch("time.sleep")
1820 def test_wait_for_existing_volumes_availability_volume_status_processing_timeout(
1823 """Exsiting volume status is processing, elapsed time greater than timeout (1800)."""
1825 existing_vim_volumes
= [{"id": volume_id2
}]
1826 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
1827 Volume("processing"),
1828 Volume("processing"),
1831 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1832 elapsed_time
, existing_vim_volumes
1834 self
.assertEqual(result
, 1805)
1835 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1836 mock_sleep
.assert_not_called()
1838 @patch("time.sleep")
1839 def test_wait_for_created_volumes_availability_cinder_raise_exception(
1842 """Cinder get volumes raises exception for created volumes."""
1844 created_items
= {f
"volume:{volume_id2}": True}
1845 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
1846 with self
.assertRaises(Exception):
1847 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1848 elapsed_time
, created_items
1850 self
.assertEqual(result
, 1000)
1851 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1852 mock_sleep
.assert_not_called()
1854 @patch("time.sleep")
1855 def test_wait_for_existing_volumes_availability_cinder_raise_exception(
1858 """Cinder get volumes raises exception for existing volumes."""
1860 existing_vim_volumes
= [{"id": volume_id2
}]
1861 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
1862 with self
.assertRaises(Exception):
1863 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1864 elapsed_time
, existing_vim_volumes
1866 self
.assertEqual(result
, 1000)
1867 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
1868 mock_sleep
.assert_not_called()
1870 @patch("time.sleep")
1871 def test_wait_for_created_volumes_availability_no_volume_in_created_items(
1874 """Created_items dict does not have volume-id."""
1878 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
1880 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
1881 elapsed_time
, created_items
1883 self
.assertEqual(result
, 10)
1884 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1885 mock_sleep
.assert_not_called()
1887 @patch("time.sleep")
1888 def test_wait_for_existing_volumes_availability_no_volume_in_existing_vim_volumes(
1891 """Existing_vim_volumes list does not have volume."""
1893 existing_vim_volumes
= []
1895 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
1897 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
1898 elapsed_time
, existing_vim_volumes
1900 self
.assertEqual(result
, 10)
1901 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
1902 mock_sleep
.assert_not_called()
1904 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
1905 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
1906 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
1907 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
1908 def test_prepare_disk_for_vm_instance(
1910 mock_existing_vol_availability
,
1911 mock_created_vol_availability
,
1912 mock_non_root_volumes
,
1915 """Prepare disks for VM instance successfully."""
1916 existing_vim_volumes
= []
1918 block_device_mapping
= {}
1919 vm_av_zone
= ["nova"]
1921 mock_root_volumes
.return_value
= root_vol_id
1922 mock_created_vol_availability
.return_value
= 10
1923 mock_existing_vol_availability
.return_value
= 15
1924 self
.vimconn
.cinder
= CopyingMock()
1925 self
.vimconn
._prepare
_disk
_for
_vminstance
(
1927 existing_vim_volumes
,
1930 block_device_mapping
,
1933 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_called_once_with(
1936 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
1937 mock_existing_vol_availability
.assert_called_once_with(10, existing_vim_volumes
)
1938 self
.assertEqual(mock_root_volumes
.call_count
, 1)
1939 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
1940 mock_root_volumes
.assert_called_once_with(
1942 vm_av_zone
=["nova"],
1943 disk
={"size": 10, "image_id": image_id
},
1945 block_device_mapping
={},
1946 existing_vim_volumes
=[],
1949 mock_non_root_volumes
.assert_called_once_with(
1952 vm_av_zone
=["nova"],
1954 block_device_mapping
={},
1955 existing_vim_volumes
=[],
1959 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
1960 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
1961 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
1962 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
1963 def test_prepare_disk_for_vm_instance_timeout_exceeded(
1965 mock_existing_vol_availability
,
1966 mock_created_vol_availability
,
1967 mock_non_root_volumes
,
1970 """Timeout exceeded while waiting for disks."""
1971 existing_vim_volumes
= []
1973 vm_av_zone
= ["nova"]
1974 block_device_mapping
= {}
1976 mock_root_volumes
.return_value
= root_vol_id
1977 mock_created_vol_availability
.return_value
= 1700
1978 mock_existing_vol_availability
.return_value
= 1900
1980 with self
.assertRaises(VimConnException
) as err
:
1981 self
.vimconn
._prepare
_disk
_for
_vminstance
(
1983 existing_vim_volumes
,
1986 block_device_mapping
,
1990 str(err
.exception
), "Timeout creating volumes for instance basicvm"
1992 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
1993 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
1994 mock_existing_vol_availability
.assert_called_once_with(
1995 1700, existing_vim_volumes
1997 self
.assertEqual(mock_root_volumes
.call_count
, 1)
1998 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
1999 mock_root_volumes
.assert_called_once_with(
2001 vm_av_zone
=["nova"],
2002 disk
={"size": 10, "image_id": image_id
},
2004 block_device_mapping
={},
2005 existing_vim_volumes
=[],
2008 mock_non_root_volumes
.assert_called_once_with(
2011 vm_av_zone
=["nova"],
2013 block_device_mapping
={},
2014 existing_vim_volumes
=[],
2018 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2019 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2020 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2021 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2022 def test_prepare_disk_for_vm_instance_empty_disk_list(
2024 mock_existing_vol_availability
,
2025 mock_created_vol_availability
,
2026 mock_non_root_volumes
,
2029 """Disk list is empty."""
2030 existing_vim_volumes
= []
2032 block_device_mapping
= {}
2033 vm_av_zone
= ["nova"]
2034 mock_created_vol_availability
.return_value
= 2
2035 mock_existing_vol_availability
.return_value
= 3
2037 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2039 existing_vim_volumes
,
2042 block_device_mapping
,
2045 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2046 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2047 mock_existing_vol_availability
.assert_called_once_with(2, existing_vim_volumes
)
2048 mock_root_volumes
.assert_not_called()
2049 mock_non_root_volumes
.assert_not_called()
2051 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2052 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2053 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2054 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2055 def test_prepare_disk_for_vm_instance_persistent_root_volume_error(
2057 mock_existing_vol_availability
,
2058 mock_created_vol_availability
,
2059 mock_non_root_volumes
,
2062 """Persistent root volumes preparation raises error."""
2063 existing_vim_volumes
= []
2065 vm_av_zone
= ["nova"]
2066 block_device_mapping
= {}
2068 mock_root_volumes
.side_effect
= Exception()
2069 mock_created_vol_availability
.return_value
= 10
2070 mock_existing_vol_availability
.return_value
= 15
2072 with self
.assertRaises(Exception):
2073 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2075 existing_vim_volumes
,
2078 block_device_mapping
,
2081 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2082 mock_created_vol_availability
.assert_not_called()
2083 mock_existing_vol_availability
.assert_not_called()
2084 mock_root_volumes
.assert_called_once_with(
2086 vm_av_zone
=["nova"],
2087 disk
={"size": 10, "image_id": image_id
},
2089 block_device_mapping
={},
2090 existing_vim_volumes
=[],
2093 mock_non_root_volumes
.assert_not_called()
2095 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2096 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2097 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2098 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2099 def test_prepare_disk_for_vm_instance_non_root_volume_error(
2101 mock_existing_vol_availability
,
2102 mock_created_vol_availability
,
2103 mock_non_root_volumes
,
2106 """Non-root volumes preparation raises error."""
2107 existing_vim_volumes
= []
2109 vm_av_zone
= ["nova"]
2110 block_device_mapping
= {}
2112 mock_root_volumes
.return_value
= root_vol_id
2113 mock_non_root_volumes
.side_effect
= Exception
2115 with self
.assertRaises(Exception):
2116 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2118 existing_vim_volumes
,
2121 block_device_mapping
,
2124 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2125 mock_created_vol_availability
.assert_not_called()
2126 mock_existing_vol_availability
.assert_not_called()
2127 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2128 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2129 mock_root_volumes
.assert_called_once_with(
2131 vm_av_zone
=["nova"],
2132 disk
={"size": 10, "image_id": image_id
},
2134 block_device_mapping
={},
2135 existing_vim_volumes
=[],
2138 mock_non_root_volumes
.assert_called_once_with(
2141 vm_av_zone
=["nova"],
2143 block_device_mapping
={},
2144 existing_vim_volumes
=[],
2148 def test_find_external_network_for_floating_ip_no_external_network(self
):
2149 """External network could not be found."""
2150 self
.vimconn
.neutron
.list_networks
.return_value
= {
2152 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": False}
2155 with self
.assertRaises(VimConnException
) as err
:
2156 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2159 "Cannot create floating_ip automatically since no external network is present",
2162 def test_find_external_network_for_floating_one_external_network(self
):
2163 """One external network has been found."""
2164 self
.vimconn
.neutron
.list_networks
.return_value
= {
2166 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True}
2169 expected_result
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
2170 result
= self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2171 self
.assertEqual(result
, expected_result
)
2173 def test_find_external_network_for_floating_neutron_raises_exception(self
):
2174 """Neutron list networks raises exception."""
2175 self
.vimconn
.neutron
.list_networks
.side_effect
= Exception
2176 with self
.assertRaises(Exception):
2177 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2179 def test_find_external_network_for_floating_several_external_network(self
):
2180 """Several exernal networks has been found."""
2181 self
.vimconn
.neutron
.list_networks
.return_value
= {
2183 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True},
2184 {"id": "608b73-y9cc-5a6a-a270-12cc4811bd4a", "router:external": True},
2187 with self
.assertRaises(VimConnException
) as err
:
2188 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2191 "Cannot create floating_ip automatically since multiple external networks are present",
2194 def test_neutron_create_float_ip(self
):
2195 """Floating ip creation is successful."""
2196 param
= {"net_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a"}
2198 self
.vimconn
.neutron
.create_floatingip
.return_value
= {
2199 "floatingip": {"id": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2201 expected_created_items
= {
2202 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True
2204 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2205 self
.assertEqual(created_items
, expected_created_items
)
2207 def test_neutron_create_float_ip_exception_occurred(self
):
2208 """Floating ip could not be created."""
2211 "floating_network_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a",
2212 "tenant_id": "308b73-19cc-8a6a-a270-02cc4811bd9a",
2216 self
.vimconn
.neutron
= CopyingMock()
2217 self
.vimconn
.neutron
.create_floatingip
.side_effect
= Exception(
2218 "Neutron floating ip create exception occurred."
2220 with self
.assertRaises(VimConnException
) as err
:
2221 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2222 self
.assertEqual(created_items
, {})
2225 "Exception: Cannot create new floating_ip Neutron floating ip create exception occurred.",
2228 @patch.object(vimconnector
, "_neutron_create_float_ip")
2229 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2230 def test_create_floating_ip_pool_id_available(
2231 self
, mock_find_ext_network
, mock_create_float_ip
2233 """Floating ip creation, ip pool is available."""
2234 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2238 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2239 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2242 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2243 mock_find_ext_network
.assert_not_called()
2244 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2246 @patch.object(vimconnector
, "_neutron_create_float_ip")
2247 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2248 def test_create_floating_ip_finding_pool_id(
2249 self
, mock_find_ext_network
, mock_create_float_ip
2251 """Floating ip creation, pool id need to be found."""
2252 floating_network
= {"floating_ip": True}
2254 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2257 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2258 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2261 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2262 mock_find_ext_network
.assert_called_once()
2263 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2265 @patch.object(vimconnector
, "_neutron_create_float_ip")
2266 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2267 def test_create_floating_ip_neutron_create_floating_ip_exception(
2268 self
, mock_find_ext_network
, mock_create_float_ip
2270 """Neutron creat floating ip raises error."""
2271 floating_network
= {"floating_ip": True}
2273 mock_create_float_ip
.side_effect
= VimConnException(
2274 "Can not create floating ip."
2276 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2279 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2280 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2284 with self
.assertRaises(VimConnException
) as err
:
2285 self
.vimconn
._create
_floating
_ip
(
2286 floating_network
, self
.server
, created_items
2288 self
.assertEqual(str(err
.exception
), "Can not create floating ip.")
2289 mock_find_ext_network
.assert_called_once()
2290 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2292 @patch.object(vimconnector
, "_neutron_create_float_ip")
2293 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2294 def test_create_floating_ip_can_not_find_pool_id(
2295 self
, mock_find_ext_network
, mock_create_float_ip
2297 """Floating ip creation, pool id could not be found."""
2298 floating_network
= {"floating_ip": True}
2300 mock_find_ext_network
.side_effect
= VimConnException(
2301 "Cannot create floating_ip automatically since no external network is present"
2303 with self
.assertRaises(VimConnException
) as err
:
2304 self
.vimconn
._create
_floating
_ip
(
2305 floating_network
, self
.server
, created_items
2309 "Cannot create floating_ip automatically since no external network is present",
2311 mock_find_ext_network
.assert_called_once()
2312 mock_create_float_ip
.assert_not_called()
2314 def test_find_floating_ip_get_free_floating_ip(self
):
2315 """Get free floating ips successfully."""
2318 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2319 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2320 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2323 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2324 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2326 result
= self
.vimconn
._find
_floating
_ip
(
2327 self
.server
, floating_ips
, floating_network
2329 self
.assertEqual(result
, expected_result
)
2331 def test_find_floating_ip_different_floating_network_id(self
):
2332 """Floating network id is different with floating_ip of floating network."""
2335 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2336 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2339 floating_network
= {"floating_ip": "508b73-t9cc-1a6a-a270-12cc4811bd4a"}
2341 result
= self
.vimconn
._find
_floating
_ip
(
2342 self
.server
, floating_ips
, floating_network
2344 self
.assertEqual(result
, None)
2346 def test_find_floating_ip_different_fip_tenant(self
):
2347 """Items in floating_ips has port_id, tenant_is is not same with server tenant id."""
2350 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2351 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2352 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2353 "tenant_id": self
.server
.id,
2356 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2357 mock_create_floating_ip
= CopyingMock()
2358 with patch
.object(vimconnector
, "_create_floating_ip", mock_create_floating_ip
):
2359 result
= self
.vimconn
._find
_floating
_ip
(
2360 self
.server
, floating_ips
, floating_network
2362 self
.assertEqual(result
, None)
2364 @patch("time.sleep")
2365 def test_assign_floating_ip(self
, mock_sleep
):
2366 """Assign floating ip successfully."""
2367 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2368 floating_network
= {"vim_id": floating_network_vim_id
}
2370 "port_id": floating_network_vim_id
,
2371 "floating_network_id": "p08b73-e9cc-5a6a-t270-82cc4811bd4a",
2372 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2373 "tenant_id": "k08b73-e9cc-5a6a-t270-82cc4811bd4a",
2375 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
2376 self
.vimconn
.neutron
.show_floatingip
.return_value
= fip
2377 expected_result
= fip
2379 result
= self
.vimconn
._assign
_floating
_ip
(free_floating_ip
, floating_network
)
2380 self
.assertEqual(result
, expected_result
)
2381 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2383 {"floatingip": {"port_id": floating_network_vim_id
}},
2385 mock_sleep
.assert_called_once_with(5)
2386 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
2388 @patch("time.sleep")
2389 def test_assign_floating_ip_update_floating_ip_exception(self
, mock_sleep
):
2390 """Neutron update floating ip raises exception."""
2391 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2392 floating_network
= {"vim_id": floating_network_vim_id
}
2393 self
.vimconn
.neutron
= CopyingMock()
2394 self
.vimconn
.neutron
.update_floatingip
.side_effect
= Exception(
2395 "Floating ip is not updated."
2398 with self
.assertRaises(Exception) as err
:
2399 result
= self
.vimconn
._assign
_floating
_ip
(
2400 free_floating_ip
, floating_network
2402 self
.assertEqual(result
, None)
2403 self
.assertEqual(str(err
.exception
), "Floating ip is not updated.")
2405 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2407 {"floatingip": {"port_id": floating_network_vim_id
}},
2409 mock_sleep
.assert_not_called()
2410 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2412 @patch("time.sleep")
2413 def test_assign_floating_ip_show_floating_ip_exception(self
, mock_sleep
):
2414 """Neutron show floating ip raises exception."""
2415 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2416 floating_network
= {"vim_id": floating_network_vim_id
}
2417 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
2418 self
.vimconn
.neutron
.show_floatingip
.side_effect
= Exception(
2419 "Floating ip could not be shown."
2422 with self
.assertRaises(Exception) as err
:
2423 result
= self
.vimconn
._assign
_floating
_ip
(
2424 free_floating_ip
, floating_network
2426 self
.assertEqual(result
, None)
2427 self
.assertEqual(str(err
.exception
), "Floating ip could not be shown.")
2428 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
2430 {"floatingip": {"port_id": floating_network_vim_id
}},
2432 mock_sleep
.assert_called_once_with(5)
2433 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
2435 @patch("random.shuffle")
2436 @patch.object(vimconnector
, "_find_floating_ip")
2437 def test_get_free_floating_ip(self
, mock_find_floating_ip
, mock_shuffle
):
2438 """Get free floating ip successfully."""
2439 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2442 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2443 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2444 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2445 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2448 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
2449 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2450 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
2451 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2454 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
2455 "floatingips": floating_ips
2457 mock_find_floating_ip
.return_value
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2458 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
2460 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2461 self
.assertEqual(result
, expected_result
)
2462 mock_shuffle
.assert_called_once_with(floating_ips
)
2463 mock_find_floating_ip
.assert_called_once_with(
2464 self
.server
, floating_ips
, floating_network
2467 @patch("random.shuffle")
2468 @patch.object(vimconnector
, "_find_floating_ip")
2469 def test_get_free_floating_ip_list_floating_ip_exception(
2470 self
, mock_find_floating_ip
, mock_shuffle
2472 """Neutron list floating IPs raises exception."""
2473 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2474 self
.vimconn
.neutron
= CopyingMock()
2475 self
.vimconn
.neutron
.list_floatingips
.side_effect
= Exception(
2476 "Floating ips could not be listed."
2478 with self
.assertRaises(Exception) as err
:
2479 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2480 self
.assertEqual(result
, None)
2481 self
.assertEqual(str(err
.exception
), "Floating ips could not be listed.")
2482 mock_shuffle
.assert_not_called()
2483 mock_find_floating_ip
.assert_not_called()
2485 @patch("random.shuffle")
2486 @patch.object(vimconnector
, "_find_floating_ip")
2487 def test_get_free_floating_ip_find_floating_ip_exception(
2488 self
, mock_find_floating_ip
, mock_shuffle
2490 """_find_floating_ip method raises exception."""
2491 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2494 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2495 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2496 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
2497 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2500 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
2501 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2502 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
2503 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
2506 self
.vimconn
.neutron
= CopyingMock()
2507 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
2508 "floatingips": floating_ips
2510 mock_find_floating_ip
.side_effect
= Exception(
2511 "Free floating ip could not be found."
2514 with self
.assertRaises(Exception) as err
:
2515 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
2516 self
.assertEqual(result
, None)
2517 self
.assertEqual(str(err
.exception
), "Free floating ip could not be found.")
2518 mock_shuffle
.assert_called_once_with(floating_ips
)
2519 mock_find_floating_ip
.assert_called_once_with(
2520 self
.server
, floating_ips
, floating_network
2523 @patch.object(vimconnector
, "_create_floating_ip")
2524 @patch.object(vimconnector
, "_get_free_floating_ip")
2525 @patch.object(vimconnector
, "_assign_floating_ip")
2526 def test_prepare_external_network_for_vm_instance(
2528 mock_assign_floating_ip
,
2529 mock_get_free_floating_ip
,
2530 mock_create_floating_ip
,
2532 """Prepare external network successfully."""
2533 external_network
= [
2535 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2536 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2540 vm_start_time
= time_return_value
2541 mock_get_free_floating_ip
.side_effect
= ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
2542 mock_assign_floating_ip
.return_value
= {
2543 "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
2545 self
.vimconn
.neutron
= CopyingMock()
2546 self
.vimconn
.nova
= CopyingMock()
2547 self
.vimconn
.neutron
.show_floatingip
.return_value
= {
2548 "floatingip": {"port_id": ""}
2551 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2552 external_network
, self
.server
, created_items
, vm_start_time
2555 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2556 mock_get_free_floating_ip
.assert_called_once_with(
2559 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2560 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2563 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(
2564 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
2566 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2567 mock_create_floating_ip
.assert_not_called()
2568 mock_assign_floating_ip
.assert_called_once_with(
2569 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2571 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2572 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2577 @patch("time.sleep")
2578 @patch.object(vimconnector
, "_create_floating_ip")
2579 @patch.object(vimconnector
, "_get_free_floating_ip")
2580 @patch.object(vimconnector
, "_assign_floating_ip")
2581 def test_prepare_external_network_for_vm_instance_no_free_floating_ip(
2583 mock_assign_floating_ip
,
2584 mock_get_free_floating_ip
,
2585 mock_create_floating_ip
,
2589 """There is not any free floating ip."""
2590 floating_network
= {
2591 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2592 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2594 external_network
= [floating_network
]
2597 vm_start_time
= time_return_value
2598 mock_get_free_floating_ip
.return_value
= None
2599 mock_assign_floating_ip
.return_value
= {}
2600 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2601 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2603 with self
.assertRaises(KeyError):
2604 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2605 external_network
, self
.server
, created_items
, vm_start_time
2608 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2609 mock_get_free_floating_ip
.assert_called_with(
2612 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2613 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2616 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(None)
2617 mock_sleep
.assert_not_called()
2618 mock_time
.assert_not_called()
2619 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
2620 mock_create_floating_ip
.assert_called_with(
2621 floating_network
, self
.server
, created_items
2623 self
.assertEqual(mock_create_floating_ip
.call_count
, 4)
2624 mock_assign_floating_ip
.assert_not_called()
2625 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2628 @patch("time.sleep")
2629 @patch.object(vimconnector
, "_create_floating_ip")
2630 @patch.object(vimconnector
, "_get_free_floating_ip")
2631 @patch.object(vimconnector
, "_assign_floating_ip")
2632 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
2634 mock_assign_floating_ip
,
2635 mock_get_free_floating_ip
,
2636 mock_create_floating_ip
,
2640 """There is not any free floating ip, create_floating ip method raise exception
2641 exit_on_floating_ip_error set to False."""
2642 floating_network
= {
2643 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2644 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2645 "exit_on_floating_ip_error": False,
2647 external_network
= [floating_network
]
2650 vm_start_time
= time_return_value
2651 mock_get_free_floating_ip
.return_value
= None
2652 mock_assign_floating_ip
.return_value
= {}
2653 mock_create_floating_ip
.side_effect
= VimConnException(
2654 "Can not create floating ip."
2656 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2657 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2659 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2660 external_network
, self
.server
, created_items
, vm_start_time
2662 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2663 mock_get_free_floating_ip
.assert_called_with(
2666 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2667 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2668 "exit_on_floating_ip_error": False,
2671 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2672 mock_sleep
.assert_not_called()
2673 mock_time
.assert_not_called()
2674 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2675 mock_create_floating_ip
.assert_called_with(
2676 floating_network
, self
.server
, created_items
2678 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
2679 mock_assign_floating_ip
.assert_not_called()
2682 @patch("time.sleep")
2683 @patch.object(vimconnector
, "_create_floating_ip")
2684 @patch.object(vimconnector
, "_get_free_floating_ip")
2685 @patch.object(vimconnector
, "_assign_floating_ip")
2686 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
2688 mock_assign_floating_ip
,
2689 mock_get_free_floating_ip
,
2690 mock_create_floating_ip
,
2694 """There is not any free floating ip, create_floating ip method raise exception
2695 exit_on_floating_ip_error set to False."""
2696 floating_network
= {
2697 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2698 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2699 "exit_on_floating_ip_error": True,
2701 external_network
= [floating_network
]
2704 vm_start_time
= time_return_value
2705 mock_get_free_floating_ip
.return_value
= None
2706 mock_assign_floating_ip
.return_value
= {}
2707 mock_create_floating_ip
.side_effect
= VimConnException(
2708 "Can not create floating ip."
2710 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2711 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
2712 with self
.assertRaises(VimConnException
):
2713 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2714 external_network
, self
.server
, created_items
, vm_start_time
2716 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
2717 mock_get_free_floating_ip
.assert_called_with(
2720 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2721 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2722 "exit_on_floating_ip_error": True,
2725 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
2726 mock_sleep
.assert_not_called()
2727 mock_time
.assert_not_called()
2728 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2729 mock_create_floating_ip
.assert_called_with(
2730 floating_network
, self
.server
, created_items
2732 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
2733 mock_assign_floating_ip
.assert_not_called()
2735 @patch.object(vimconnector
, "_create_floating_ip")
2736 @patch.object(vimconnector
, "_get_free_floating_ip")
2737 @patch.object(vimconnector
, "_assign_floating_ip")
2738 def test_prepare_external_network_for_vm_instance_fip_has_port_id(
2740 mock_assign_floating_ip
,
2741 mock_get_free_floating_ip
,
2742 mock_create_floating_ip
,
2744 """Neutron show floating ip return the fip with port_id and floating network vim_id
2745 is different from port_id."""
2746 floating_network
= {
2747 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2748 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2750 external_network
= [floating_network
]
2753 mock_get_free_floating_ip
.side_effect
= [
2754 "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
2755 "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
2756 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2758 mock_assign_floating_ip
.side_effect
= [
2759 {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2760 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2762 self
.vimconn
.neutron
= CopyingMock()
2763 self
.vimconn
.nova
= CopyingMock()
2764 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2765 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
2766 {"floatingip": {"port_id": ""}},
2767 {"floatingip": {"port_id": ""}},
2769 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2770 external_network
, self
.server
, created_items
, vm_start_time
2772 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
2773 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2775 _call_mock_get_free_floating_ip
[0][0],
2782 _call_mock_get_free_floating_ip
[1][0],
2789 _call_mock_get_free_floating_ip
[2][0],
2795 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
2796 self
.vimconn
.nova
.servers
.get
.assert_not_called()
2797 mock_create_floating_ip
.assert_not_called()
2798 self
.assertEqual(mock_assign_floating_ip
.call_count
, 2)
2799 _call_mock_assign_floating_ip
= mock_assign_floating_ip
.call_args_list
2801 _call_mock_assign_floating_ip
[0][0],
2802 ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
2805 _call_mock_assign_floating_ip
[1][0],
2806 ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
2810 @patch("time.sleep")
2811 @patch.object(vimconnector
, "_create_floating_ip")
2812 @patch.object(vimconnector
, "_get_free_floating_ip")
2813 @patch.object(vimconnector
, "_assign_floating_ip")
2814 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
2816 mock_assign_floating_ip
,
2817 mock_get_free_floating_ip
,
2818 mock_create_floating_ip
,
2822 """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
2823 VM status is in error."""
2824 floating_network
= {
2825 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2826 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2827 "exit_on_floating_ip_error": True,
2829 external_network
= [floating_network
]
2831 vm_start_time
= time_return_value
2833 mock_time
.side_effect
= [156570150, 156570800, 156571200]
2835 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
2836 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2837 Exception("Floating ip could not be shown.")
2839 with self
.assertRaises(Exception) as err
:
2840 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2841 external_network
, self
.server
, created_items
, vm_start_time
2845 "Cannot create floating_ip: Exception Floating ip could not be shown.",
2848 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2849 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2851 _call_mock_get_free_floating_ip
[0][0],
2858 _call_mock_get_free_floating_ip
[1][0],
2865 _call_mock_get_free_floating_ip
[2][0],
2872 _call_mock_get_free_floating_ip
[3][0],
2879 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
2880 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2881 mock_create_floating_ip
.assert_not_called()
2882 mock_assign_floating_ip
.assert_not_called()
2883 mock_time
.assert_not_called()
2884 mock_sleep
.assert_not_called()
2887 @patch("time.sleep")
2888 @patch.object(vimconnector
, "_create_floating_ip")
2889 @patch.object(vimconnector
, "_get_free_floating_ip")
2890 @patch.object(vimconnector
, "_assign_floating_ip")
2891 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
2893 mock_assign_floating_ip
,
2894 mock_get_free_floating_ip
,
2895 mock_create_floating_ip
,
2899 """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
2900 VM status is in active."""
2901 floating_network
= {
2902 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2903 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2904 "exit_on_floating_ip_error": False,
2906 external_network
= [floating_network
]
2908 vm_start_time
= time_return_value
2910 mock_time
.side_effect
= [156570150, 156570800, 156571200]
2912 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ACTIVE"
2913 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2914 Exception("Floating ip could not be shown.")
2917 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2918 external_network
, self
.server
, created_items
, vm_start_time
2920 # self.assertEqual(str(err.exception), "Cannot create floating_ip")
2922 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
2923 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
2925 _call_mock_get_free_floating_ip
[0][0],
2932 _call_mock_get_free_floating_ip
[1][0],
2939 _call_mock_get_free_floating_ip
[2][0],
2946 _call_mock_get_free_floating_ip
[3][0],
2953 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
2954 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
2955 mock_create_floating_ip
.assert_not_called()
2956 mock_assign_floating_ip
.assert_not_called()
2957 mock_time
.assert_not_called()
2958 mock_sleep
.assert_not_called()
2961 @patch("time.sleep")
2962 @patch.object(vimconnector
, "_create_floating_ip")
2963 @patch.object(vimconnector
, "_get_free_floating_ip")
2964 @patch.object(vimconnector
, "_assign_floating_ip")
2965 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
2967 mock_assign_floating_ip
,
2968 mock_get_free_floating_ip
,
2969 mock_create_floating_ip
,
2973 """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
2974 VM status is not ACTIVE or ERROR, server timeout happened."""
2975 floating_network
= {
2976 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
2977 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
2978 "exit_on_floating_ip_error": True,
2980 external_network
= [floating_network
]
2982 vm_start_time
= time_return_value
2983 mock_get_free_floating_ip
.side_effect
= None
2984 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
2985 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "OTHER"
2986 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
2987 Exception("Floating ip could not be shown.")
2990 with self
.assertRaises(VimConnException
) as err
:
2991 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
2992 external_network
, self
.server
, created_items
, vm_start_time
2996 "Cannot create floating_ip: Exception Floating ip could not be shown.",
2999 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3000 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3002 _call_mock_get_free_floating_ip
[0][0],
3009 _call_mock_get_free_floating_ip
[1][0],
3016 _call_mock_get_free_floating_ip
[2][0],
3023 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3024 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3025 mock_create_floating_ip
.assert_not_called()
3026 mock_assign_floating_ip
.assert_not_called()
3027 self
.assertEqual(mock_time
.call_count
, 3)
3028 self
.assertEqual(mock_sleep
.call_count
, 2)
3031 @patch("time.sleep")
3032 @patch.object(vimconnector
, "_create_floating_ip")
3033 @patch.object(vimconnector
, "_get_free_floating_ip")
3034 @patch.object(vimconnector
, "_assign_floating_ip")
3035 def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3037 mock_assign_floating_ip
,
3038 mock_get_free_floating_ip
,
3039 mock_create_floating_ip
,
3043 """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3044 VM status is in ERROR."""
3045 floating_network
= {
3046 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3047 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3048 "exit_on_floating_ip_error": True,
3050 external_network
= [floating_network
]
3052 vm_start_time
= time_return_value
3054 mock_get_free_floating_ip
.side_effect
= [
3055 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3058 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3060 mock_assign_floating_ip
.side_effect
= [
3061 Exception("Floating ip could not be assigned.")
3064 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3065 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3066 {"floatingip": {"port_id": ""}}
3069 with self
.assertRaises(VimConnException
) as err
:
3070 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3071 external_network
, self
.server
, created_items
, vm_start_time
3075 "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3078 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3079 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3081 _call_mock_get_free_floating_ip
[0][0],
3088 _call_mock_get_free_floating_ip
[1][0],
3095 _call_mock_get_free_floating_ip
[2][0],
3102 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3103 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(
3104 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3106 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3107 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3108 mock_time
.assert_not_called()
3109 mock_sleep
.assert_not_called()
3110 mock_create_floating_ip
.assert_not_called()
3113 @patch("time.sleep")
3114 @patch.object(vimconnector
, "_create_floating_ip")
3115 @patch.object(vimconnector
, "_get_free_floating_ip")
3116 @patch.object(vimconnector
, "_assign_floating_ip")
3117 def test_prepare_external_network_for_vm_instance_empty_external_network_list(
3119 mock_assign_floating_ip
,
3120 mock_get_free_floating_ip
,
3121 mock_create_floating_ip
,
3125 """External network list is empty."""
3126 external_network
= []
3128 vm_start_time
= time_return_value
3130 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3131 external_network
, self
.server
, created_items
, vm_start_time
3133 mock_create_floating_ip
.assert_not_called()
3134 mock_time
.assert_not_called()
3135 mock_sleep
.assert_not_called()
3136 mock_assign_floating_ip
.assert_not_called()
3137 mock_get_free_floating_ip
.assert_not_called()
3138 self
.vimconn
.neutron
.show
.show_floatingip
.assert_not_called()
3139 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3141 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3142 def test_update_port_security_for_vm_instance(self
, mock_wait_for_vm
):
3143 """no_secured_ports has port and the port has allow-address-pairs."""
3144 no_secured_ports
= [(port2_id
, "allow-address-pairs")]
3146 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3148 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3150 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3152 {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
3155 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3156 def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
3157 self
, mock_wait_for_vm
3159 """no_secured_ports has port and the port does not have allow-address-pairs."""
3160 no_secured_ports
= [(port2_id
, "something")]
3162 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3164 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3166 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3168 {"port": {"port_security_enabled": False, "security_groups": None}},
3171 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3172 def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
3173 self
, mock_wait_for_vm
3175 """__wait_for_vm raises timeout exception."""
3176 no_secured_ports
= [(port2_id
, "something")]
3178 mock_wait_for_vm
.side_effect
= VimConnException("Timeout waiting for instance.")
3180 with self
.assertRaises(VimConnException
) as err
:
3181 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3182 no_secured_ports
, self
.server
3184 self
.assertEqual(str(err
.exception
), "Timeout waiting for instance.")
3186 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3188 self
.vimconn
.neutron
.update_port
.assert_not_called()
3190 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3191 def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
3192 self
, mock_wait_for_vm
3194 """neutron_update_port method raises exception."""
3195 no_secured_ports
= [(port2_id
, "something")]
3197 self
.vimconn
.neutron
.update_port
.side_effect
= Exception(
3198 "Port security could not be updated."
3201 with self
.assertRaises(VimConnException
) as err
:
3202 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3203 no_secured_ports
, self
.server
3207 "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
3209 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3211 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3213 {"port": {"port_security_enabled": False, "security_groups": None}},
3216 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3217 def test_update_port_security_for_vm_instance_empty_port_list(
3218 self
, mock_wait_for_vm
3220 """no_secured_ports list does not have any ports."""
3221 no_secured_ports
= []
3223 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3225 mock_wait_for_vm
.assert_not_called()
3227 self
.vimconn
.neutron
.update_port
.assert_not_called()
3230 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3231 @patch.object(vimconnector
, "_reload_connection")
3232 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3233 @patch.object(vimconnector
, "_create_user_data")
3234 @patch.object(vimconnector
, "_get_vm_availability_zone")
3235 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3236 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3237 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3238 @patch.object(vimconnector
, "delete_vminstance")
3239 @patch.object(vimconnector
, "_format_exception")
3240 def test_new_vm_instance(
3242 mock_format_exception
,
3243 mock_delete_vm_instance
,
3244 mock_prepare_external_network
,
3245 mock_update_port_security
,
3246 mock_prepare_disk_for_vm_instance
,
3247 mock_get_vm_availability_zone
,
3248 mock_create_user_data
,
3249 mock_prepare_network_for_vm_instance
,
3250 mock_reload_connection
,
3251 mock_remove_keep_flag_from_persistent_volumes
,
3254 """New VM instance creation is successful."""
3256 mock_create_user_data
.return_value
= True, "userdata"
3258 mock_get_vm_availability_zone
.return_value
= "nova"
3260 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3262 mock_time
.return_value
= time_return_value
3264 expected_result
= self
.server
.id, {}
3266 result
= self
.vimconn
.new_vminstance(
3272 affinity_group_list
,
3276 availability_zone_index
,
3277 availability_zone_list
,
3279 self
.assertEqual(result
, expected_result
)
3281 mock_reload_connection
.assert_called_once()
3282 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3287 external_network
=[],
3288 no_secured_ports
=[],
3290 mock_create_user_data
.assert_called_once_with(cloud_config
)
3291 mock_get_vm_availability_zone
.assert_called_once_with(
3292 availability_zone_index
, availability_zone_list
3294 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3296 existing_vim_volumes
=[],
3299 block_device_mapping
={},
3300 disk_list
=disk_list2
,
3302 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3307 security_groups
="default",
3308 availability_zone
="nova",
3309 key_name
="my_keypair",
3310 userdata
="userdata",
3312 block_device_mapping
={},
3315 mock_time
.assert_called_once()
3316 mock_update_port_security
.assert_called_once_with([], self
.server
)
3317 mock_prepare_external_network
.assert_called_once_with(
3318 external_network
=[],
3321 vm_start_time
=time_return_value
,
3323 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
3324 mock_delete_vm_instance
.assert_not_called()
3325 mock_format_exception
.assert_not_called()
3328 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3329 @patch.object(vimconnector
, "_reload_connection")
3330 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3331 @patch.object(vimconnector
, "_create_user_data")
3332 @patch.object(vimconnector
, "_get_vm_availability_zone")
3333 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3334 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3335 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3336 @patch.object(vimconnector
, "delete_vminstance")
3337 @patch.object(vimconnector
, "_format_exception")
3338 def test_new_vm_instance_create_user_data_fails(
3340 mock_format_exception
,
3341 mock_delete_vm_instance
,
3342 mock_prepare_external_network
,
3343 mock_update_port_security
,
3344 mock_prepare_disk_for_vm_instance
,
3345 mock_get_vm_availability_zone
,
3346 mock_create_user_data
,
3347 mock_prepare_network_for_vm_instance
,
3348 mock_reload_connection
,
3349 mock_remove_keep_flag_from_persistent_volumes
,
3352 """New VM instance creation failed because of user data creation failure."""
3354 mock_create_user_data
.side_effect
= Exception(
3355 "User data could not be retrieved."
3358 mock_get_vm_availability_zone
.return_value
= "nova"
3360 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3362 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3364 mock_time
.return_value
= time_return_value
3366 self
.vimconn
.new_vminstance(
3372 affinity_group_list
,
3376 availability_zone_index
,
3377 availability_zone_list
,
3380 mock_reload_connection
.assert_called_once()
3381 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3386 external_network
=[],
3387 no_secured_ports
=[],
3389 mock_create_user_data
.assert_called_once_with(cloud_config
)
3390 mock_get_vm_availability_zone
.assert_not_called()
3391 mock_prepare_disk_for_vm_instance
.assert_not_called()
3392 self
.vimconn
.nova
.servers
.create
.assert_not_called()
3393 mock_time
.assert_not_called()
3394 mock_update_port_security
.assert_not_called()
3395 mock_prepare_external_network
.assert_not_called()
3396 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3397 mock_delete_vm_instance
.assert_called_once_with(None, {})
3398 mock_format_exception
.assert_called_once()
3399 arg
= mock_format_exception
.call_args
[0][0]
3400 self
.assertEqual(str(arg
), "User data could not be retrieved.")
3403 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3404 @patch.object(vimconnector
, "_reload_connection")
3405 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3406 @patch.object(vimconnector
, "_create_user_data")
3407 @patch.object(vimconnector
, "_get_vm_availability_zone")
3408 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3409 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3410 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3411 @patch.object(vimconnector
, "delete_vminstance")
3412 @patch.object(vimconnector
, "_format_exception")
3413 def test_new_vm_instance_external_network_exception(
3415 mock_format_exception
,
3416 mock_delete_vm_instance
,
3417 mock_prepare_external_network
,
3418 mock_update_port_security
,
3419 mock_prepare_disk_for_vm_instance
,
3420 mock_get_vm_availability_zone
,
3421 mock_create_user_data
,
3422 mock_prepare_network_for_vm_instance
,
3423 mock_reload_connection
,
3424 mock_remove_keep_flag_from_persistent_volumes
,
3427 """New VM instance creation, external network connection has failed as floating
3428 ip could not be created."""
3430 mock_create_user_data
.return_value
= True, "userdata"
3432 mock_get_vm_availability_zone
.return_value
= "nova"
3434 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3436 mock_time
.return_value
= time_return_value
3438 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3440 mock_prepare_external_network
.side_effect
= VimConnException(
3441 "Can not create floating ip."
3444 self
.vimconn
.new_vminstance(
3450 affinity_group_list
,
3454 availability_zone_index
,
3455 availability_zone_list
,
3458 mock_reload_connection
.assert_called_once()
3459 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3464 external_network
=[],
3465 no_secured_ports
=[],
3467 mock_create_user_data
.assert_called_once_with(cloud_config
)
3468 mock_get_vm_availability_zone
.assert_called_once_with(
3469 availability_zone_index
, availability_zone_list
3471 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3473 existing_vim_volumes
=[],
3476 block_device_mapping
={},
3477 disk_list
=disk_list2
,
3479 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3484 security_groups
="default",
3485 availability_zone
="nova",
3486 key_name
="my_keypair",
3487 userdata
="userdata",
3489 block_device_mapping
={},
3492 mock_time
.assert_called_once()
3493 mock_update_port_security
.assert_called_once_with([], self
.server
)
3494 mock_prepare_external_network
.assert_called_once_with(
3495 external_network
=[],
3498 vm_start_time
=time_return_value
,
3500 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3501 mock_delete_vm_instance
.assert_called_once_with(self
.server
.id, {})
3502 mock_format_exception
.assert_called_once()
3503 arg
= mock_format_exception
.call_args
[0][0]
3504 self
.assertEqual(str(arg
), "Can not create floating ip.")
3507 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3508 @patch.object(vimconnector
, "_reload_connection")
3509 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3510 @patch.object(vimconnector
, "_create_user_data")
3511 @patch.object(vimconnector
, "_get_vm_availability_zone")
3512 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3513 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3514 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3515 @patch.object(vimconnector
, "delete_vminstance")
3516 @patch.object(vimconnector
, "_format_exception")
3517 def test_new_vm_instance_with_affinity_group(
3519 mock_format_exception
,
3520 mock_delete_vm_instance
,
3521 mock_prepare_external_network
,
3522 mock_update_port_security
,
3523 mock_prepare_disk_for_vm_instance
,
3524 mock_get_vm_availability_zone
,
3525 mock_create_user_data
,
3526 mock_prepare_network_for_vm_instance
,
3527 mock_reload_connection
,
3528 mock_remove_keep_flag_from_persistent_volumes
,
3531 """New VM creation with affinity group."""
3532 affinity_group_list
= [
3533 {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
3535 mock_create_user_data
.return_value
= True, "userdata"
3536 mock_get_vm_availability_zone
.return_value
= "nova"
3537 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3538 mock_time
.return_value
= time_return_value
3539 expected_result
= self
.server
.id, {}
3541 result
= self
.vimconn
.new_vminstance(
3547 affinity_group_list
,
3551 availability_zone_index
,
3552 availability_zone_list
,
3554 self
.assertEqual(result
, expected_result
)
3556 mock_reload_connection
.assert_called_once()
3557 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3562 external_network
=[],
3563 no_secured_ports
=[],
3565 mock_create_user_data
.assert_called_once_with(cloud_config
)
3566 mock_get_vm_availability_zone
.assert_called_once_with(
3567 availability_zone_index
, availability_zone_list
3569 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3571 existing_vim_volumes
=[],
3574 block_device_mapping
={},
3575 disk_list
=disk_list2
,
3577 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3582 security_groups
="default",
3583 availability_zone
="nova",
3584 key_name
="my_keypair",
3585 userdata
="userdata",
3587 block_device_mapping
={},
3588 scheduler_hints
={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
3590 mock_time
.assert_called_once()
3591 mock_update_port_security
.assert_called_once_with([], self
.server
)
3592 mock_prepare_external_network
.assert_called_once_with(
3593 external_network
=[],
3596 vm_start_time
=time_return_value
,
3598 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
3599 mock_delete_vm_instance
.assert_not_called()
3600 mock_format_exception
.assert_not_called()
3603 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3604 @patch.object(vimconnector
, "_reload_connection")
3605 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3606 @patch.object(vimconnector
, "_create_user_data")
3607 @patch.object(vimconnector
, "_get_vm_availability_zone")
3608 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3609 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3610 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3611 @patch.object(vimconnector
, "delete_vminstance")
3612 @patch.object(vimconnector
, "_format_exception")
3613 def test_new_vm_instance_nova_server_create_failed(
3615 mock_format_exception
,
3616 mock_delete_vm_instance
,
3617 mock_prepare_external_network
,
3618 mock_update_port_security
,
3619 mock_prepare_disk_for_vm_instance
,
3620 mock_get_vm_availability_zone
,
3621 mock_create_user_data
,
3622 mock_prepare_network_for_vm_instance
,
3623 mock_reload_connection
,
3624 mock_remove_keep_flag_from_persistent_volumes
,
3627 """New VM(server) creation failed."""
3629 mock_create_user_data
.return_value
= True, "userdata"
3631 mock_get_vm_availability_zone
.return_value
= "nova"
3633 self
.vimconn
.nova
.servers
.create
.side_effect
= Exception(
3634 "Server could not be created."
3637 mock_time
.return_value
= time_return_value
3639 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3641 self
.vimconn
.new_vminstance(
3647 affinity_group_list
,
3651 availability_zone_index
,
3652 availability_zone_list
,
3655 mock_reload_connection
.assert_called_once()
3656 mock_prepare_network_for_vm_instance
.assert_called_once_with(
3661 external_network
=[],
3662 no_secured_ports
=[],
3664 mock_create_user_data
.assert_called_once_with(cloud_config
)
3665 mock_get_vm_availability_zone
.assert_called_once_with(
3666 availability_zone_index
, availability_zone_list
3668 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
3670 existing_vim_volumes
=[],
3673 block_device_mapping
={},
3674 disk_list
=disk_list2
,
3677 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
3682 security_groups
="default",
3683 availability_zone
="nova",
3684 key_name
="my_keypair",
3685 userdata
="userdata",
3687 block_device_mapping
={},
3690 mock_time
.assert_not_called()
3691 mock_update_port_security
.assert_not_called()
3692 mock_prepare_external_network
.assert_not_called()
3693 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3694 mock_delete_vm_instance
.assert_called_once_with(None, {})
3695 mock_format_exception
.assert_called_once()
3696 arg
= mock_format_exception
.call_args
[0][0]
3697 self
.assertEqual(str(arg
), "Server could not be created.")
3700 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
3701 @patch.object(vimconnector
, "_reload_connection")
3702 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3703 @patch.object(vimconnector
, "_create_user_data")
3704 @patch.object(vimconnector
, "_get_vm_availability_zone")
3705 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3706 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3707 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3708 @patch.object(vimconnector
, "delete_vminstance")
3709 @patch.object(vimconnector
, "_format_exception")
3710 def test_new_vm_instance_connection_exception(
3712 mock_format_exception
,
3713 mock_delete_vm_instance
,
3714 mock_prepare_external_network
,
3715 mock_update_port_security
,
3716 mock_prepare_disk_for_vm_instance
,
3717 mock_get_vm_availability_zone
,
3718 mock_create_user_data
,
3719 mock_prepare_network_for_vm_instance
,
3720 mock_reload_connection
,
3721 mock_remove_keep_flag_from_persistent_volumes
,
3724 """Connection to Cloud API has failed."""
3725 mock_reload_connection
.side_effect
= Exception("Can not connect to Cloud APIs.")
3726 mock_create_user_data
.return_value
= True, "userdata"
3727 mock_get_vm_availability_zone
.return_value
= "nova"
3728 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3729 mock_time
.return_value
= time_return_value
3730 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
3732 self
.vimconn
.new_vminstance(
3738 affinity_group_list
,
3742 availability_zone_index
,
3743 availability_zone_list
,
3745 mock_format_exception
.assert_called_once()
3746 arg
= mock_format_exception
.call_args
[0][0]
3747 self
.assertEqual(str(arg
), "Can not connect to Cloud APIs.")
3748 mock_reload_connection
.assert_called_once()
3749 mock_prepare_network_for_vm_instance
.assert_not_called()
3750 mock_create_user_data
.assert_not_called()
3751 mock_get_vm_availability_zone
.assert_not_called()
3752 mock_prepare_disk_for_vm_instance
.assert_not_called()
3753 self
.vimconn
.nova
.servers
.create
.assert_not_called()
3754 mock_time
.assert_not_called()
3755 mock_update_port_security
.assert_not_called()
3756 mock_prepare_external_network
.assert_not_called()
3757 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
3758 mock_delete_vm_instance
.assert_called_once_with(None, {})
3760 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3761 def test_delete_vm_ports_attached_to_network_empty_created_items(
3762 self
, mock_delete_ports_by_id_wth_neutron
3764 """Created_items is emtpty."""
3766 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3767 self
.vimconn
.neutron
.list_ports
.assert_not_called()
3768 self
.vimconn
.neutron
.delete_port
.assert_not_called()
3769 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3771 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3772 def test_delete_vm_ports_attached_to_network(
3773 self
, mock_delete_ports_by_id_wth_neutron
3776 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
3777 f
"volume:{volume_id2}": True,
3778 f
"volume:{volume_id}": True,
3779 f
"port:{port_id}": True,
3781 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3782 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3783 self
.vimconn
.logger
.error
.assert_not_called()
3785 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3786 def test_delete_vm_ports_attached_to_network_wthout_port(
3787 self
, mock_delete_ports_by_id_wth_neutron
3789 """Created_items does not have port."""
3791 f
"floating_ip:{floating_network_vim_id}": True,
3792 f
"volume:{volume_id2}": True,
3793 f
"volume:{volume_id}": True,
3795 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3796 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3797 self
.vimconn
.logger
.error
.assert_not_called()
3799 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3800 def test_delete_vm_ports_attached_to_network_delete_port_raise_vimconnexception(
3801 self
, mock_delete_ports_by_id_wth_neutron
3803 """_delete_ports_by_id_wth_neutron raises vimconnexception."""
3804 created_items
= deepcopy(created_items_all_true
)
3805 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
3806 "Can not delete port"
3808 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3809 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3810 self
.vimconn
.logger
.error
.assert_called_once_with(
3811 "Error deleting port: VimConnException: Can not delete port"
3814 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3815 def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
3816 self
, mock_delete_ports_by_id_wth_neutron
3818 """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
3819 created_items
= deepcopy(created_items_all_true
)
3820 mock_delete_ports_by_id_wth_neutron
.side_effect
= nvExceptions
.ClientException(
3821 "Connection aborted."
3823 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3824 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
3825 self
.vimconn
.logger
.error
.assert_called_once_with(
3826 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
3829 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3830 def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
3831 self
, mock_delete_ports_by_id_wth_neutron
3833 """port item is invalid."""
3835 f
"floating_ip:{floating_network_vim_id}": True,
3836 f
"volume:{volume_id2}": True,
3837 f
"volume:{volume_id}": True,
3838 f
"port:{port_id}:": True,
3840 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
3841 "Port is not valid."
3843 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3844 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}:")
3845 self
.vimconn
.logger
.error
.assert_called_once_with(
3846 "Error deleting port: VimConnException: Port is not valid."
3849 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
3850 def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
3851 self
, mock_delete_ports_by_id_wth_neutron
3853 """port is already deleted."""
3855 f
"floating_ip:{floating_network_vim_id}": True,
3856 f
"volume:{volume_id2}": True,
3857 f
"volume:{volume_id}": None,
3858 f
"port:{port_id}": None,
3860 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3861 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
3862 self
.vimconn
.logger
.error
.assert_not_called()
3864 def test_delete_floating_ip_by_id(self
):
3866 f
"floating_ip:{floating_network_vim_id}": True,
3867 f
"port:{port_id}": True,
3869 expected_created_items
= {
3870 f
"floating_ip:{floating_network_vim_id}": None,
3871 f
"port:{port_id}": True,
3873 k_id
= floating_network_vim_id
3874 k
= f
"floating_ip:{floating_network_vim_id}"
3875 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3876 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3877 self
.assertEqual(created_items
, expected_created_items
)
3879 def test_delete_floating_ip_by_id_floating_ip_already_deleted(self
):
3880 """floating ip is already deleted."""
3882 f
"floating_ip:{floating_network_vim_id}": None,
3883 f
"port:{port_id}": True,
3885 k_id
= floating_network_vim_id
3886 k
= f
"floating_ip:{floating_network_vim_id}"
3887 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3888 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3892 f
"floating_ip:{floating_network_vim_id}": None,
3893 f
"port:{port_id}": True,
3897 def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self
):
3898 """netron delete floating ip raises nvExceptions.ClientException."""
3900 f
"floating_ip:{floating_network_vim_id}": True,
3901 f
"port:{port_id}": True,
3903 k_id
= floating_network_vim_id
3904 k
= f
"floating_ip:{floating_network_vim_id}"
3905 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= (
3906 nvExceptions
.ClientException("Client exception occurred.")
3908 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3909 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3913 f
"floating_ip:{floating_network_vim_id}": True,
3914 f
"port:{port_id}": True,
3917 self
.vimconn
.logger
.error
.assert_called_once_with(
3918 "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occurred.)"
3921 def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self
):
3922 """netron delete floating ip raises VimConnNotFoundException."""
3924 f
"floating_ip:{floating_network_vim_id}": True,
3925 f
"port:{port_id}": True,
3927 k_id
= floating_network_vim_id
3928 k
= f
"floating_ip:{floating_network_vim_id}"
3929 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= VimConnNotFoundException(
3930 "Port id could not found."
3932 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3933 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3937 f
"floating_ip:{floating_network_vim_id}": True,
3938 f
"port:{port_id}": True,
3941 self
.vimconn
.logger
.error
.assert_called_once_with(
3942 "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
3945 def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self
):
3946 """invalid floating ip item."""
3948 f
"floating_ip:{floating_network_vim_id}": True,
3949 f
"port:{port_id}": True,
3951 expected_created_items
= {
3952 f
"floating_ip:{floating_network_vim_id}::": None,
3953 f
"floating_ip:{floating_network_vim_id}": True,
3954 f
"port:{port_id}": True,
3956 k_id
= floating_network_vim_id
3957 k
= f
"floating_ip:{floating_network_vim_id}::"
3958 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
3959 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
3960 self
.assertEqual(created_items
, expected_created_items
)
3962 def test_delete_volumes_by_id_with_cinder_volume_status_available(self
):
3963 """volume status is available."""
3965 f
"floating_ip:{floating_network_vim_id}": True,
3966 f
"volume:{volume_id2}": True,
3967 f
"volume:{volume_id}": True,
3968 f
"port:{port_id}": None,
3970 expected_created_items
= {
3971 f
"floating_ip:{floating_network_vim_id}": True,
3972 f
"volume:{volume_id2}": True,
3973 f
"volume:{volume_id}": None,
3974 f
"port:{port_id}": None,
3976 volumes_to_hold
= []
3977 k
= f
"volume:{volume_id}"
3979 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
3980 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
3981 k
, k_id
, volumes_to_hold
, created_items
3983 self
.assertEqual(result
, None)
3984 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
3985 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
3986 self
.vimconn
.logger
.error
.assert_not_called()
3987 self
.assertEqual(created_items
, expected_created_items
)
3989 def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self
):
3990 """volume is already deleted."""
3992 f
"floating_ip:{floating_network_vim_id}": True,
3993 f
"volume:{volume_id2}": True,
3994 f
"volume:{volume_id}": None,
3995 f
"port:{port_id}": None,
3997 expected_created_items
= {
3998 f
"floating_ip:{floating_network_vim_id}": True,
3999 f
"volume:{volume_id2}": True,
4000 f
"volume:{volume_id}": None,
4001 f
"port:{port_id}": None,
4003 volumes_to_hold
= []
4004 k
= f
"volume:{volume_id}"
4006 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4007 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4008 k
, k_id
, volumes_to_hold
, created_items
4010 self
.assertEqual(result
, None)
4011 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4012 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4013 self
.vimconn
.logger
.error
.assert_not_called()
4014 self
.assertEqual(created_items
, expected_created_items
)
4016 def test_delete_shared_volumes(self
):
4017 """cinder delete shared volumes"""
4018 shared_volume_vim_id
= volume_id4
4019 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4020 self
.vimconn
.delete_shared_volumes(shared_volume_vim_id
)
4021 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(shared_volume_vim_id
)
4022 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(shared_volume_vim_id
)
4023 self
.vimconn
.logger
.error
.assert_not_called()
4025 def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self
):
4026 """cinder get volume raises exception."""
4028 f
"floating_ip:{floating_network_vim_id}": True,
4029 f
"volume:{volume_id2}": True,
4030 f
"volume:{volume_id}": True,
4031 f
"port:{port_id}": None,
4033 expected_created_items
= {
4034 f
"floating_ip:{floating_network_vim_id}": True,
4035 f
"volume:{volume_id2}": True,
4036 f
"volume:{volume_id}": True,
4037 f
"port:{port_id}": None,
4039 volumes_to_hold
= []
4040 k
= f
"volume:{volume_id}"
4042 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception(
4043 "Can not get volume status."
4045 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4046 k
, k_id
, volumes_to_hold
, created_items
4048 self
.assertEqual(result
, None)
4049 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4050 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4051 self
.vimconn
.logger
.error
.assert_called_once_with(
4052 "Error deleting volume: Exception: Can not get volume status."
4054 self
.assertEqual(created_items
, expected_created_items
)
4056 def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self
):
4057 """cinder delete volume raises exception."""
4059 f
"floating_ip:{floating_network_vim_id}": True,
4060 f
"volume:{volume_id2}": True,
4061 f
"volume:{volume_id}": True,
4062 f
"port:{port_id}": None,
4064 expected_created_items
= {
4065 f
"floating_ip:{floating_network_vim_id}": True,
4066 f
"volume:{volume_id2}": True,
4067 f
"volume:{volume_id}": True,
4068 f
"port:{port_id}": None,
4070 volumes_to_hold
= []
4071 k
= f
"volume:{volume_id}"
4073 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4074 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= nvExceptions
.ClientException(
4075 "Connection aborted."
4077 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4078 k
, k_id
, volumes_to_hold
, created_items
4080 self
.assertEqual(result
, None)
4081 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4082 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4083 self
.vimconn
.logger
.error
.assert_called_once_with(
4084 "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
4086 self
.assertEqual(created_items
, expected_created_items
)
4088 def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self
):
4089 """volume_to_hold has item."""
4091 f
"floating_ip:{floating_network_vim_id}": True,
4092 f
"volume:{volume_id2}": True,
4093 f
"volume:{volume_id}": True,
4094 f
"port:{port_id}": None,
4096 expected_created_items
= {
4097 f
"floating_ip:{floating_network_vim_id}": True,
4098 f
"volume:{volume_id2}": True,
4099 f
"volume:{volume_id}": True,
4100 f
"port:{port_id}": None,
4102 volumes_to_hold
= [volume_id
]
4103 k
= f
"volume:{volume_id}"
4105 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4106 k
, k_id
, volumes_to_hold
, created_items
4108 self
.assertEqual(result
, None)
4109 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
4110 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4111 self
.vimconn
.logger
.error
.assert_not_called()
4112 self
.assertEqual(created_items
, expected_created_items
)
4114 def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self
):
4115 """volume status is not available."""
4117 f
"floating_ip:{floating_network_vim_id}": True,
4118 f
"volume:{volume_id2}": True,
4119 f
"volume:{volume_id}": True,
4120 f
"port:{port_id}": None,
4122 expected_created_items
= {
4123 f
"floating_ip:{floating_network_vim_id}": True,
4124 f
"volume:{volume_id2}": True,
4125 f
"volume:{volume_id}": True,
4126 f
"port:{port_id}": None,
4128 volumes_to_hold
= []
4129 k
= f
"volume:{volume_id}"
4131 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "unavailable"
4132 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4133 k
, k_id
, volumes_to_hold
, created_items
4135 self
.assertEqual(result
, True)
4136 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4137 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4138 self
.vimconn
.logger
.error
.assert_not_called()
4139 self
.assertEqual(created_items
, expected_created_items
)
4141 def test_delete_ports_by_id_by_neutron(self
):
4142 """neutron delete ports."""
4144 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4145 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4146 self
.vimconn
.logger
.error
.assert_not_called()
4148 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
4149 """neutron delete port raises exception."""
4151 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
4152 "Connection aborted."
4154 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4155 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4156 self
.vimconn
.logger
.error
.assert_called_once_with(
4157 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4160 def test_get_item_name_id(self
):
4161 """Get name and id successfully."""
4162 k
= f
"some:{port_id}"
4163 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4164 self
.assertEqual(result
, ("some", f
"{port_id}"))
4166 def test_get_item_name_id_wthout_semicolon(self
):
4167 """Does not have seperator."""
4168 k
= f
"some{port_id}"
4169 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4170 self
.assertEqual(result
, (f
"some{port_id}", ""))
4172 def test_get_item_name_id_empty_string(self
):
4175 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4176 self
.assertEqual(result
, ("", ""))
4178 def test_get_item_name_id_k_is_none(self
):
4181 with self
.assertRaises(AttributeError):
4182 self
.vimconn
._get
_item
_name
_id
(k
)
4184 @patch.object(vimconnector
, "_get_item_name_id")
4185 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4186 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4187 def test_delete_created_items(
4189 mock_delete_floating_ip_by_id
,
4190 mock_delete_volumes_by_id_wth_cinder
,
4191 mock_get_item_name_id
,
4193 """Created items has floating ip and volume."""
4195 f
"floating_ip:{floating_network_vim_id}": True,
4196 f
"volume:{volume_id}": True,
4197 f
"port:{port_id}": None,
4199 mock_get_item_name_id
.side_effect
= [
4200 ("floating_ip", f
"{floating_network_vim_id}"),
4201 ("volume", f
"{volume_id}"),
4203 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4204 volumes_to_hold
= []
4205 keep_waiting
= False
4206 result
= self
.vimconn
._delete
_created
_items
(
4207 created_items
, volumes_to_hold
, keep_waiting
4209 self
.assertEqual(result
, True)
4210 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4211 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4212 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4214 mock_delete_floating_ip_by_id
.assert_called_once_with(
4215 f
"floating_ip:{floating_network_vim_id}",
4216 f
"{floating_network_vim_id}",
4219 self
.vimconn
.logger
.error
.assert_not_called()
4221 @patch.object(vimconnector
, "_get_item_name_id")
4222 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4223 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4224 def test_delete_created_items_wth_volumes_to_hold(
4226 mock_delete_floating_ip_by_id
,
4227 mock_delete_volumes_by_id_wth_cinder
,
4228 mock_get_item_name_id
,
4230 """Created items has floating ip and volume and volumes_to_hold has items."""
4232 f
"floating_ip:{floating_network_vim_id}": True,
4233 f
"volume:{volume_id}": True,
4234 f
"port:{port_id}": None,
4236 mock_get_item_name_id
.side_effect
= [
4237 ("floating_ip", f
"{floating_network_vim_id}"),
4238 ("volume", f
"{volume_id}"),
4240 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4241 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4242 keep_waiting
= False
4243 result
= self
.vimconn
._delete
_created
_items
(
4244 created_items
, volumes_to_hold
, keep_waiting
4246 self
.assertEqual(result
, True)
4247 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4248 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4249 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4251 mock_delete_floating_ip_by_id
.assert_called_once_with(
4252 f
"floating_ip:{floating_network_vim_id}",
4253 f
"{floating_network_vim_id}",
4256 self
.vimconn
.logger
.error
.assert_not_called()
4258 @patch.object(vimconnector
, "_get_item_name_id")
4259 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4260 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4261 def test_delete_created_items_wth_keep_waiting_true(
4263 mock_delete_floating_ip_by_id
,
4264 mock_delete_volumes_by_id_wth_cinder
,
4265 mock_get_item_name_id
,
4267 """Keep waiting initial value is True."""
4269 f
"floating_ip:{floating_network_vim_id}": True,
4270 f
"volume:{volume_id}": True,
4271 f
"port:{port_id}": None,
4273 mock_get_item_name_id
.side_effect
= [
4274 ("floating_ip", f
"{floating_network_vim_id}"),
4275 ("volume", f
"{volume_id}"),
4277 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4278 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4280 result
= self
.vimconn
._delete
_created
_items
(
4281 created_items
, volumes_to_hold
, keep_waiting
4283 self
.assertEqual(result
, True)
4284 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4285 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4286 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4288 mock_delete_floating_ip_by_id
.assert_called_once_with(
4289 f
"floating_ip:{floating_network_vim_id}",
4290 f
"{floating_network_vim_id}",
4293 self
.vimconn
.logger
.error
.assert_not_called()
4295 @patch.object(vimconnector
, "_get_item_name_id")
4296 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4297 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4298 def test_delete_created_items_delete_vol_raises(
4300 mock_delete_floating_ip_by_id
,
4301 mock_delete_volumes_by_id_wth_cinder
,
4302 mock_get_item_name_id
,
4304 """Delete volume raises exception."""
4306 f
"floating_ip:{floating_network_vim_id}": True,
4307 f
"volume:{volume_id}": True,
4308 f
"port:{port_id}": None,
4310 mock_get_item_name_id
.side_effect
= [
4311 ("floating_ip", f
"{floating_network_vim_id}"),
4312 ("volume", f
"{volume_id}"),
4314 mock_delete_volumes_by_id_wth_cinder
.side_effect
= ConnectionError(
4315 "Connection failed."
4317 volumes_to_hold
= []
4318 keep_waiting
= False
4319 result
= self
.vimconn
._delete
_created
_items
(
4320 created_items
, volumes_to_hold
, keep_waiting
4322 self
.assertEqual(result
, False)
4323 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4324 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4325 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4327 mock_delete_floating_ip_by_id
.assert_called_once_with(
4328 f
"floating_ip:{floating_network_vim_id}",
4329 f
"{floating_network_vim_id}",
4332 self
.vimconn
.logger
.error
.assert_called_once_with(
4333 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
4336 @patch.object(vimconnector
, "_get_item_name_id")
4337 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4338 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4339 def test_delete_created_items_delete_fip_raises(
4341 mock_delete_floating_ip_by_id
,
4342 mock_delete_volumes_by_id_wth_cinder
,
4343 mock_get_item_name_id
,
4345 """Delete floating ip raises exception."""
4347 f
"floating_ip:{floating_network_vim_id}": True,
4348 f
"volume:{volume_id}": True,
4349 f
"port:{port_id}": None,
4351 mock_get_item_name_id
.side_effect
= [
4352 ("floating_ip", f
"{floating_network_vim_id}"),
4353 ("volume", f
"{volume_id}"),
4355 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4356 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
4357 "Connection failed."
4359 volumes_to_hold
= []
4361 result
= self
.vimconn
._delete
_created
_items
(
4362 created_items
, volumes_to_hold
, keep_waiting
4364 self
.assertEqual(result
, True)
4365 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4366 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4367 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4369 mock_delete_floating_ip_by_id
.assert_called_once_with(
4370 f
"floating_ip:{floating_network_vim_id}",
4371 f
"{floating_network_vim_id}",
4374 self
.vimconn
.logger
.error
.assert_called_once_with(
4375 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
4378 @patch.object(vimconnector
, "_get_item_name_id")
4379 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4380 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4381 def test_delete_created_items_get_item_name_raises(
4383 mock_delete_floating_ip_by_id
,
4384 mock_delete_volumes_by_id_wth_cinder
,
4385 mock_get_item_name_id
,
4387 """Get item, name raises exception."""
4390 f
"volume{volume_id}": True,
4391 f
"port:{port_id}": None,
4393 mock_get_item_name_id
.side_effect
= [
4394 TypeError("Invalid Type"),
4395 AttributeError("Invalid attribute"),
4397 volumes_to_hold
= []
4398 keep_waiting
= False
4399 result
= self
.vimconn
._delete
_created
_items
(
4400 created_items
, volumes_to_hold
, keep_waiting
4402 self
.assertEqual(result
, False)
4403 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4404 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4405 mock_delete_floating_ip_by_id
.assert_not_called()
4406 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
4407 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
4410 (f
"Error deleting volume{volume_id}: Invalid attribute",),
4413 @patch.object(vimconnector
, "_get_item_name_id")
4414 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4415 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4416 def test_delete_created_items_no_fip_wth_port(
4418 mock_delete_floating_ip_by_id
,
4419 mock_delete_volumes_by_id_wth_cinder
,
4420 mock_get_item_name_id
,
4422 """Created items has port, does not have floating ip."""
4424 f
"volume:{volume_id}": True,
4425 f
"port:{port_id}": True,
4427 mock_get_item_name_id
.side_effect
= [
4428 ("volume", f
"{volume_id}"),
4429 ("port", f
"{port_id}"),
4431 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4432 volumes_to_hold
= []
4433 keep_waiting
= False
4434 result
= self
.vimconn
._delete
_created
_items
(
4435 created_items
, volumes_to_hold
, keep_waiting
4437 self
.assertEqual(result
, False)
4438 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4439 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4440 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4442 mock_delete_floating_ip_by_id
.assert_not_called()
4443 self
.vimconn
.logger
.error
.assert_not_called()
4445 @patch.object(vimconnector
, "_get_item_name_id")
4446 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4447 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4448 def test_delete_created_items_no_volume(
4450 mock_delete_floating_ip_by_id
,
4451 mock_delete_volumes_by_id_wth_cinder
,
4452 mock_get_item_name_id
,
4454 """Created items does not have volume."""
4456 f
"floating_ip:{floating_network_vim_id}": True,
4457 f
"port:{port_id}": None,
4459 mock_get_item_name_id
.side_effect
= [
4460 ("floating_ip", f
"{floating_network_vim_id}")
4462 volumes_to_hold
= []
4463 keep_waiting
= False
4464 result
= self
.vimconn
._delete
_created
_items
(
4465 created_items
, volumes_to_hold
, keep_waiting
4467 self
.assertEqual(result
, False)
4468 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
4469 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4470 mock_delete_floating_ip_by_id
.assert_called_once_with(
4471 f
"floating_ip:{floating_network_vim_id}",
4472 f
"{floating_network_vim_id}",
4475 self
.vimconn
.logger
.error
.assert_not_called()
4477 @patch.object(vimconnector
, "_get_item_name_id")
4478 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4479 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4480 def test_delete_created_items_already_deleted(
4482 mock_delete_floating_ip_by_id
,
4483 mock_delete_volumes_by_id_wth_cinder
,
4484 mock_get_item_name_id
,
4486 """All created items are alerady deleted."""
4488 f
"floating_ip:{floating_network_vim_id}": None,
4489 f
"volume:{volume_id}": None,
4490 f
"port:{port_id}": None,
4492 volumes_to_hold
= []
4493 keep_waiting
= False
4494 result
= self
.vimconn
._delete
_created
_items
(
4495 created_items
, volumes_to_hold
, keep_waiting
4497 self
.assertEqual(result
, False)
4498 mock_get_item_name_id
.assert_not_called()
4499 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4500 mock_delete_floating_ip_by_id
.assert_not_called()
4501 self
.vimconn
.logger
.error
.assert_not_called()
4503 @patch("time.sleep")
4504 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4505 @patch.object(vimconnector
, "_format_exception")
4506 @patch.object(vimconnector
, "_reload_connection")
4507 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4508 @patch.object(vimconnector
, "_delete_created_items")
4509 def test_delete_vminstance_successfully(
4511 mock_delete_created_items
,
4512 mock_delete_vm_ports_attached_to_network
,
4513 mock_reload_connection
,
4514 mock_format_exception
,
4515 mock_extract_items_wth_keep_flag_from_created_items
,
4518 vm_id
= f
"{virtual_mac_id}"
4519 created_items
= deepcopy(created_items_all_true
)
4520 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4521 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4522 mock_delete_created_items
.return_value
= False
4523 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4524 mock_reload_connection
.assert_called_once()
4525 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4526 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4527 mock_delete_created_items
.assert_called_once_with(
4528 created_items
, volumes_to_hold
, False
4530 mock_sleep
.assert_not_called()
4531 mock_format_exception
.assert_not_called()
4532 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
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_created_items_has_keep_flag(
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 """Created_items includes items which has keep flag."""
4552 vm_id
= f
"{virtual_mac_id}"
4553 initial_created_items
= {
4554 f
"port{port_id}": True,
4555 f
"floating_ip{floating_network_vim_id}": None,
4556 f
"volume{volume_id}keep": True,
4557 f
"volume{volume_id2}keep": True,
4560 f
"port{port_id}": True,
4561 f
"floating_ip{floating_network_vim_id}": None,
4563 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4564 volumes_to_hold
= []
4565 mock_delete_created_items
.return_value
= False
4566 self
.vimconn
.delete_vminstance(vm_id
, initial_created_items
, volumes_to_hold
)
4567 mock_reload_connection
.assert_called_once()
4568 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4569 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4570 mock_delete_created_items
.assert_called_once_with(
4571 created_items
, volumes_to_hold
, False
4573 mock_sleep
.assert_not_called()
4574 mock_format_exception
.assert_not_called()
4575 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4576 initial_created_items
4579 @patch("time.sleep")
4580 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4581 @patch.object(vimconnector
, "_format_exception")
4582 @patch.object(vimconnector
, "_reload_connection")
4583 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4584 @patch.object(vimconnector
, "_delete_created_items")
4585 def test_delete_vminstance_extract_items_wth_keep_raises(
4587 mock_delete_created_items
,
4588 mock_delete_vm_ports_attached_to_network
,
4589 mock_reload_connection
,
4590 mock_format_exception
,
4591 mock_extract_items_wth_keep_flag_from_created_items
,
4594 """extract_items_wth_keep_flag_from_created_items raises AttributeError."""
4595 vm_id
= f
"{virtual_mac_id}"
4596 initial_created_items
= {
4597 f
"port{port_id}": True,
4598 f
"floating_ip{floating_network_vim_id}": None,
4599 f
"volume{volume_id}keep": True,
4600 f
"volume{volume_id2}keep": True,
4603 mock_extract_items_wth_keep_flag_from_created_items
.side_effect
= AttributeError
4604 volumes_to_hold
= []
4605 mock_delete_created_items
.return_value
= False
4606 with self
.assertRaises(AttributeError):
4607 self
.vimconn
.delete_vminstance(
4608 vm_id
, initial_created_items
, volumes_to_hold
4610 mock_reload_connection
.assert_not_called()
4611 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4612 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4613 mock_delete_created_items
.assert_not_called()
4614 mock_sleep
.assert_not_called()
4615 mock_format_exception
.assert_not_called()
4616 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4617 initial_created_items
4620 @patch("time.sleep")
4621 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4622 @patch.object(vimconnector
, "_format_exception")
4623 @patch.object(vimconnector
, "_reload_connection")
4624 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4625 @patch.object(vimconnector
, "_delete_created_items")
4626 def test_delete_vminstance_delete_created_items_raises(
4628 mock_delete_created_items
,
4629 mock_delete_vm_ports_attached_to_network
,
4630 mock_reload_connection
,
4631 mock_format_exception
,
4632 mock_extract_items_wth_keep_flag_from_created_items
,
4635 """Delete creted items raises exception."""
4636 vm_id
= f
"{virtual_mac_id}"
4637 created_items
= deepcopy(created_items_all_true
)
4638 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4639 mock_sleep
= MagicMock()
4640 volumes_to_hold
= []
4641 err
= ConnectionError("ClientException occurred.")
4642 mock_delete_created_items
.side_effect
= err
4643 with self
.assertRaises(ConnectionError
) as err
:
4644 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4645 self
.assertEqual(str(err
), "ClientException occurred.")
4646 mock_reload_connection
.assert_called_once()
4647 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4648 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4649 mock_delete_created_items
.assert_called_once()
4650 mock_sleep
.assert_not_called()
4651 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4655 @patch("time.sleep")
4656 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4657 @patch.object(vimconnector
, "_format_exception")
4658 @patch.object(vimconnector
, "_reload_connection")
4659 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4660 @patch.object(vimconnector
, "_delete_created_items")
4661 def test_delete_vminstance_delete_vm_ports_raises(
4663 mock_delete_created_items
,
4664 mock_delete_vm_ports_attached_to_network
,
4665 mock_reload_connection
,
4666 mock_format_exception
,
4667 mock_extract_items_wth_keep_flag_from_created_items
,
4670 """Delete vm ports raises exception."""
4671 vm_id
= f
"{virtual_mac_id}"
4672 created_items
= deepcopy(created_items_all_true
)
4673 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4674 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4675 err
= ConnectionError("ClientException occurred.")
4676 mock_delete_vm_ports_attached_to_network
.side_effect
= err
4677 mock_delete_created_items
.side_effect
= err
4678 with self
.assertRaises(ConnectionError
) as err
:
4679 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4680 self
.assertEqual(str(err
), "ClientException occurred.")
4681 mock_reload_connection
.assert_called_once()
4682 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4683 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4684 mock_delete_created_items
.assert_not_called()
4685 mock_sleep
.assert_not_called()
4686 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4690 @patch("time.sleep")
4691 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4692 @patch.object(vimconnector
, "_format_exception")
4693 @patch.object(vimconnector
, "_reload_connection")
4694 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4695 @patch.object(vimconnector
, "_delete_created_items")
4696 def test_delete_vminstance_nova_server_delete_raises(
4698 mock_delete_created_items
,
4699 mock_delete_vm_ports_attached_to_network
,
4700 mock_reload_connection
,
4701 mock_format_exception
,
4702 mock_extract_items_wth_keep_flag_from_created_items
,
4705 """Nova server delete raises exception."""
4706 vm_id
= f
"{virtual_mac_id}"
4707 created_items
= deepcopy(created_items_all_true
)
4708 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4709 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4710 err
= VimConnConnectionException("ClientException occurred.")
4711 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
4712 mock_delete_created_items
.side_effect
= err
4713 with self
.assertRaises(VimConnConnectionException
) as err
:
4714 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4715 self
.assertEqual(str(err
), "ClientException occurred.")
4716 mock_reload_connection
.assert_called_once()
4717 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4718 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4719 mock_delete_created_items
.assert_not_called()
4720 mock_sleep
.assert_not_called()
4721 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4725 @patch("time.sleep")
4726 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4727 @patch.object(vimconnector
, "_format_exception")
4728 @patch.object(vimconnector
, "_reload_connection")
4729 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4730 @patch.object(vimconnector
, "_delete_created_items")
4731 def test_delete_vminstance_reload_connection_raises(
4733 mock_delete_created_items
,
4734 mock_delete_vm_ports_attached_to_network
,
4735 mock_reload_connection
,
4736 mock_format_exception
,
4737 mock_extract_items_wth_keep_flag_from_created_items
,
4740 """Reload connection raises exception."""
4741 vm_id
= f
"{virtual_mac_id}"
4742 created_items
= deepcopy(created_items_all_true
)
4743 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4744 mock_sleep
= MagicMock()
4745 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4746 err
= ConnectionError("ClientException occurred.")
4747 mock_delete_created_items
.return_value
= False
4748 mock_reload_connection
.side_effect
= err
4749 with self
.assertRaises(ConnectionError
) as err
:
4750 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4751 self
.assertEqual(str(err
), "ClientException occurred.")
4752 mock_reload_connection
.assert_called_once()
4753 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4754 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4755 mock_delete_created_items
.assert_not_called()
4756 mock_sleep
.assert_not_called()
4757 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4761 @patch("time.sleep")
4762 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4763 @patch.object(vimconnector
, "_format_exception")
4764 @patch.object(vimconnector
, "_reload_connection")
4765 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4766 @patch.object(vimconnector
, "_delete_created_items")
4767 def test_delete_vminstance_created_item_vol_to_hold_are_none(
4769 mock_delete_created_items
,
4770 mock_delete_vm_ports_attached_to_network
,
4771 mock_reload_connection
,
4772 mock_format_exception
,
4773 mock_extract_items_wth_keep_flag_from_created_items
,
4776 """created_items and volumes_to_hold are None."""
4777 vm_id
= f
"{virtual_mac_id}"
4778 created_items
= None
4779 volumes_to_hold
= None
4780 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= {}
4781 mock_delete_created_items
.return_value
= False
4782 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4783 mock_reload_connection
.assert_called_once()
4784 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4785 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4786 mock_delete_created_items
.assert_called_once_with({}, [], False)
4787 mock_sleep
.assert_not_called()
4788 mock_format_exception
.assert_not_called()
4789 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with({})
4791 @patch("time.sleep")
4792 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4793 @patch.object(vimconnector
, "_format_exception")
4794 @patch.object(vimconnector
, "_reload_connection")
4795 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4796 @patch.object(vimconnector
, "_delete_created_items")
4797 def test_delete_vminstance_vm_id_is_none(
4799 mock_delete_created_items
,
4800 mock_delete_vm_ports_attached_to_network
,
4801 mock_reload_connection
,
4802 mock_format_exception
,
4803 mock_extract_items_wth_keep_flag_from_created_items
,
4806 """vm_id is None."""
4808 created_items
= deepcopy(created_items_all_true
)
4809 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4810 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4811 mock_delete_created_items
.side_effect
= [True, True, False]
4812 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4813 mock_reload_connection
.assert_called_once()
4814 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4815 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4816 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
4817 self
.assertEqual(mock_sleep
.call_count
, 2)
4818 mock_format_exception
.assert_not_called()
4819 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4823 @patch("time.sleep")
4824 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4825 @patch.object(vimconnector
, "_format_exception")
4826 @patch.object(vimconnector
, "_reload_connection")
4827 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4828 @patch.object(vimconnector
, "_delete_created_items")
4829 def test_delete_vminstance_delete_created_items_return_true(
4831 mock_delete_created_items
,
4832 mock_delete_vm_ports_attached_to_network
,
4833 mock_reload_connection
,
4834 mock_format_exception
,
4835 mock_extract_items_wth_keep_flag_from_created_items
,
4838 """Delete created items always return True."""
4840 created_items
= deepcopy(created_items_all_true
)
4841 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4842 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4843 mock_delete_created_items
.side_effect
= [True] * 1800
4844 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4845 mock_reload_connection
.assert_called_once()
4846 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4847 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4848 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
4849 self
.assertEqual(mock_sleep
.call_count
, 1800)
4850 mock_format_exception
.assert_not_called()
4851 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4855 def test_remove_keep_tag_from_persistent_volumes_keep_flag_exists(self
):
4856 """Keep flag exists in created items."""
4858 f
"port:{port_id}": True,
4859 f
"floating_ip:{floating_network_vim_id}": True,
4860 f
"volume:{volume_id}:keep": True,
4861 f
"volume:{volume_id2}:keep": True,
4864 f
"port:{port_id}": True,
4865 f
"floating_ip:{floating_network_vim_id}": True,
4866 f
"volume:{volume_id}": True,
4867 f
"volume:{volume_id2}": True,
4869 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4870 self
.assertDictEqual(result
, expected_result
)
4872 def test_remove_keep_tag_from_persistent_volumes_without_keep_flag(self
):
4873 """Keep flag does not exist in created items."""
4875 f
"port:{port_id}": True,
4876 f
"floating_ip:{floating_network_vim_id}": True,
4877 f
"volume:{volume_id}": True,
4878 f
"volume:{volume_id2}": True,
4880 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4881 self
.assertDictEqual(result
, created_items
)
4883 def test_update_block_device_mapping_empty_volume(self
):
4885 block_device_mapping
= {}
4886 base_disk_index
= 100
4889 with self
.assertRaises(VimConnException
) as err
:
4890 self
.vimconn
.update_block_device_mapping(
4891 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4893 self
.assertEqual(str(err
), "Volume is empty.")
4894 self
.assertEqual(block_device_mapping
, {})
4895 self
.assertEqual(created_items
, {})
4897 def test_update_block_device_mapping_invalid_volume(self
):
4899 block_device_mapping
= {}
4900 base_disk_index
= 100
4903 with self
.assertRaises(VimConnException
) as err
:
4904 self
.vimconn
.update_block_device_mapping(
4905 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4908 str(err
), "Created volume is not valid, does not have id attribute."
4910 self
.assertEqual(block_device_mapping
, {})
4911 self
.assertEqual(created_items
, {})
4913 def test_update_block_device_mapping(self
):
4914 volume
= MagicMock(autospec
=True)
4915 volume
.id = volume_id
4916 block_device_mapping
= {}
4917 base_disk_index
= 100
4920 self
.vimconn
.update_block_device_mapping(
4921 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4924 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4927 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a": True}
4930 def test_update_block_device_mapping_with_keep_flag(self
):
4931 volume
= MagicMock(autospec
=True)
4932 volume
.id = volume_id
4933 block_device_mapping
= {}
4934 base_disk_index
= 100
4935 disk
= {"size": 10, "keep": True}
4937 self
.vimconn
.update_block_device_mapping(
4938 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4941 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4944 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a:keep": True}
4947 def test_extract_items_with_keep_flag_item_has_keep_flag(self
):
4948 created_items
= deepcopy(created_items_all_true
)
4949 created_items
[f
"volume:{volume_id2}:keep"] = True
4950 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4953 self
.assertEqual(result
, deepcopy(created_items_all_true
))
4955 def test_extract_items_with_keep_flag_no_item_wth_keep_flag(self
):
4956 created_items
= deepcopy(created_items_all_true
)
4957 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4960 self
.assertEqual(result
, deepcopy(created_items_all_true
))
4962 def test_extract_items_with_keep_flag_all_items_are_already_deleted(self
):
4964 f
"port:{port_id}": None,
4965 f
"floating_ip:{floating_network_vim_id}": None,
4966 f
"volume:{volume_id}:keep": None,
4967 f
"volume:{volume_id2}:keep": None,
4970 f
"port:{port_id}": None,
4971 f
"floating_ip:{floating_network_vim_id}": None,
4973 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4976 self
.assertEqual(result
, expected_result
)
4978 def test_extract_items_with_keep_flag_without_semicolon(self
):
4980 f
"port{port_id}": True,
4981 f
"floating_ip{floating_network_vim_id}": None,
4982 f
"volume{volume_id}keep": True,
4983 f
"volume{volume_id2}keep": True,
4985 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4988 self
.assertEqual(result
, {})
4990 def test_extract_items_with_keep_flag_invalid_type_created_items(self
):
4991 created_items
= [{f
"port{port_id}": True}, {f
"volume{volume_id2}keep": True}]
4992 with self
.assertRaises(AttributeError):
4993 self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(created_items
)
4995 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
4996 def test_get_monitoring_data(self
, mock_reload_conection
):
4998 {"original_name": "flavor1", "id": "367fc1eb-bd22-40f8-a519-ed2fb4e5976b"},
4999 {"original_name": "flavor2", "id": "5dcf9732-d17d-40b3-910d-37fc4c5aacc0"},
5003 "server1", "ACTIVE", flavors
[0], "312200db-42e3-4772-9518-d5db85468392"
5006 "server2", "ACTIVE", flavors
[1], "39a166cf-e4e6-479c-b88c-9ad558cf2cbf"
5009 ports
= {"ports": ["port1", "port2"]}
5010 self
.vimconn
.nova
.servers
.list.return_value
= servers
5011 self
.vimconn
.neutron
.list_ports
.return_value
= ports
5012 result
= self
.vimconn
.get_monitoring_data()
5013 self
.assertTupleEqual(result
, (servers
, ports
))
5014 mock_reload_conection
.assert_called_once()
5015 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5016 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5018 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5019 def test_get_monitoring_data_reload_connection_raises(self
, mock_reload_conection
):
5020 mock_reload_conection
.side_effect
= VimConnNotFoundException(
5021 "Connection object not found."
5023 with self
.assertRaises(VimConnException
) as err
:
5024 result
= self
.vimconn
.get_monitoring_data()
5025 self
.assertTupleEqual(result
, None)
5027 str(err
.exception
.args
[0]),
5028 "Exception in monitoring while getting VMs and ports status: Connection object not found.",
5030 mock_reload_conection
.assert_called_once()
5031 check_if_assert_not_called(
5032 [self
.vimconn
.nova
.servers
.list, self
.vimconn
.neutron
.list_ports
]
5035 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5036 def test_get_monitoring_data_server_list_raises(self
, mock_reload_conection
):
5037 self
.vimconn
.nova
.servers
.list.side_effect
= VimConnConnectionException(
5038 "Can not connect to Cloud API."
5040 with self
.assertRaises(VimConnException
) as err
:
5041 result
= self
.vimconn
.get_monitoring_data()
5042 self
.assertTupleEqual(result
, None)
5044 str(err
.exception
.args
[0]),
5045 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
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_not_called()
5051 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5052 def test_get_monitoring_data_list_ports_raises(self
, mock_reload_conection
):
5053 self
.vimconn
.neutron
.list_ports
.side_effect
= VimConnConnectionException(
5054 "Can not connect to Cloud API."
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: Can not connect to Cloud API.",
5063 mock_reload_conection
.assert_called_once()
5064 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5065 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5068 class TestNewFlavor(unittest
.TestCase
):
5069 @patch("logging.getLogger", autospec
=True)
5070 def setUp(self
, mock_logger
):
5071 # We are disabling the logging of exception not to print them to console.
5072 mock_logger
= logging
.getLogger()
5073 mock_logger
.disabled
= True
5074 self
.vimconn
= vimconnector(
5084 self
.vimconn
.nova
= CopyingMock(autospec
=True)
5085 self
.flavor1
= CopyingMock(autospec
=True, name
="sample-flavor")
5086 self
.flavor2
= CopyingMock(autospec
=True, name
="other-flavor")
5087 self
.new_flavor
= CopyingMock(autospec
=True, name
="new_flavor")
5088 self
.new_flavor
.id = "075d2482-5edb-43e3-91b3-234e65b6268a"
5089 self
.vimconn
.nova
.flavors
.create
.return_value
= self
.new_flavor
5091 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5092 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5093 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5096 "process_numa_paired_threads",
5097 new_callable
=CopyingMock(),
5099 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5100 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5101 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_vio(
5103 mock_process_numa_threads
,
5104 mock_process_numa_cores
,
5105 mock_process_numa_paired_threads
,
5106 mock_process_numa_vcpu
,
5107 mock_process_numa_memory
,
5108 mock_process_vio_numa_nodes
,
5110 """Process numa parameters, id, memory, vcpu exist, vim type is VIO,
5111 paired-threads, cores, threads do not exist in numa.
5114 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5115 {"id": 1, "memory": 2, "vcpu": [2]},
5118 expected_extra_specs
= {
5119 "hw:numa_nodes": "2",
5120 "hw:cpu_sockets": "2",
5122 self
.vimconn
.vim_type
= "VIO"
5123 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5125 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5126 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5127 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5128 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5130 _call_mock_process_numa_memory
[0].args
,
5132 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5135 "hw:numa_nodes": "2",
5140 _call_mock_process_numa_memory
[1].args
,
5142 {"id": 1, "memory": 2, "vcpu": [2]},
5145 "hw:cpu_sockets": "2",
5146 "hw:numa_nodes": "2",
5150 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5152 _call_mock_process_numa_vcpu
[0].args
,
5154 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5157 "hw:numa_nodes": "2",
5162 _call_mock_process_numa_vcpu
[1].args
,
5164 {"id": 1, "memory": 2, "vcpu": [2]},
5167 "hw:cpu_sockets": "2",
5168 "hw:numa_nodes": "2",
5172 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5173 check_if_assert_not_called(
5175 mock_process_numa_threads
,
5176 mock_process_numa_cores
,
5177 mock_process_numa_paired_threads
,
5181 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5182 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5183 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5186 "process_numa_paired_threads",
5187 new_callable
=CopyingMock(),
5189 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5190 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5191 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_openstack(
5193 mock_process_numa_threads
,
5194 mock_process_numa_cores
,
5195 mock_process_numa_paired_threads
,
5196 mock_process_numa_vcpu
,
5197 mock_process_numa_memory
,
5198 mock_process_vio_numa_nodes
,
5200 """Process numa parameters, id, memory, vcpu exist, vim type is openstack,
5201 paired-threads, cores, threads do not exist in numa.
5204 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5205 {"id": 1, "memory": 2, "vcpu": [2]},
5208 expected_extra_specs
= {
5209 "hw:numa_nodes": "2",
5210 "hw:cpu_sockets": "2",
5212 self
.vimconn
.vim_type
= "openstack"
5213 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5215 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5216 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5217 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5219 _call_mock_process_numa_memory
[0].args
,
5221 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5223 {"hw:numa_nodes": "2"},
5227 _call_mock_process_numa_memory
[1].args
,
5229 {"id": 1, "memory": 2, "vcpu": [2]},
5231 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5234 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5236 _call_mock_process_numa_vcpu
[0].args
,
5238 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5240 {"hw:numa_nodes": "2"},
5244 _call_mock_process_numa_vcpu
[1].args
,
5246 {"id": 1, "memory": 2, "vcpu": [2]},
5248 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5251 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5252 check_if_assert_not_called(
5254 mock_process_numa_threads
,
5255 mock_process_numa_cores
,
5256 mock_process_numa_paired_threads
,
5260 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5261 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5262 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5265 "process_numa_paired_threads",
5266 new_callable
=CopyingMock(),
5268 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5269 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5270 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_openstack_extra_spec_not_empty(
5272 mock_process_numa_threads
,
5273 mock_process_numa_cores
,
5274 mock_process_numa_paired_threads
,
5275 mock_process_numa_vcpu
,
5276 mock_process_numa_memory
,
5277 mock_process_vio_numa_nodes
,
5279 """Process numa parameters, id, paired-threads exist, vim type is openstack.
5280 vcpus calculation according to paired-threads in numa, there is extra_spec.
5282 numas
= [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
5283 extra_specs
= {"some-key": "some-value"}
5284 expected_extra_specs
= {
5285 "hw:cpu_sockets": "2",
5286 "hw:cpu_threads": "12",
5287 "hw:numa_nodes": "2",
5288 "some-key": "some-value",
5290 self
.vimconn
.vim_type
= "openstack"
5291 mock_process_numa_paired_threads
.side_effect
= [6, 6]
5292 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5294 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5295 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5296 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5297 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5298 _call_mock_process_numa_paired_threads
= (
5299 mock_process_numa_paired_threads
.call_args_list
5302 _call_mock_process_numa_paired_threads
[0].args
,
5304 {"id": 0, "paired-threads": 3},
5305 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5309 _call_mock_process_numa_paired_threads
[1].args
,
5311 {"id": 1, "paired-threads": 3},
5312 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5315 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5317 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5318 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5319 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5322 "process_numa_paired_threads",
5323 new_callable
=CopyingMock(),
5325 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5326 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5327 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_vio_extra_spec_not_empty(
5329 mock_process_numa_threads
,
5330 mock_process_numa_cores
,
5331 mock_process_numa_paired_threads
,
5332 mock_process_numa_vcpu
,
5333 mock_process_numa_memory
,
5334 mock_process_vio_numa_nodes
,
5336 """Process numa parameters, id, paired-threads exist, vim type is VIO.
5337 vcpus calculation according to paired-threads in numa, there is extra_spec.
5339 numas
= [{"id": 0, "paired-threads": 2}, {"id": 1, "paired-threads": 2}]
5340 extra_specs
= {"some-key": "some-value"}
5341 expected_extra_specs
= {
5342 "hw:numa_nodes": "2",
5343 "hw:cpu_sockets": "2",
5344 "hw:cpu_threads": "8",
5345 "some-key": "some-value",
5347 self
.vimconn
.vim_type
= "VIO"
5348 mock_process_numa_paired_threads
.side_effect
= [4, 4]
5349 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5350 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5351 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5352 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5353 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5354 _call_mock_process_numa_paired_threads
= (
5355 mock_process_numa_paired_threads
.call_args_list
5357 mock_process_vio_numa_nodes
.assert_called_once_with(
5358 2, {"some-key": "some-value", "hw:numa_nodes": "2"}
5361 _call_mock_process_numa_paired_threads
[0].args
,
5363 {"id": 0, "paired-threads": 2},
5365 "hw:cpu_sockets": "2",
5366 "hw:numa_nodes": "2",
5367 "some-key": "some-value",
5372 _call_mock_process_numa_paired_threads
[1].args
,
5374 {"id": 1, "paired-threads": 2},
5376 "hw:cpu_sockets": "2",
5377 "hw:numa_nodes": "2",
5378 "some-key": "some-value",
5382 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5384 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5385 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5386 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5389 "process_numa_paired_threads",
5390 new_callable
=CopyingMock(),
5392 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5393 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5394 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_openstack(
5396 mock_process_numa_threads
,
5397 mock_process_numa_cores
,
5398 mock_process_numa_paired_threads
,
5399 mock_process_numa_vcpu
,
5400 mock_process_numa_memory
,
5401 mock_process_vio_numa_nodes
,
5403 """Process numa parameters, id, cores exist, vim type is openstack.
5404 vcpus calculation according to cores in numa.
5406 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5408 updated_extra_specs
= {"hw:numa_nodes": "2", "hw:cpu_sockets": "2"}
5409 expected_extra_specs
= {
5410 "hw:numa_nodes": "2",
5411 "hw:cpu_sockets": "2",
5412 "hw:cpu_cores": "3",
5414 self
.vimconn
.vim_type
= "openstack"
5415 mock_process_numa_cores
.side_effect
= [1, 2]
5416 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5418 check_if_assert_not_called(
5419 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5421 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5422 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5423 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5424 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5426 _call_mock_process_numa_cores
[0].args
,
5427 ({"id": 0, "cores": 1}, updated_extra_specs
),
5430 _call_mock_process_numa_cores
[1].args
,
5431 ({"id": 1, "cores": 2}, updated_extra_specs
),
5433 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5435 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5436 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5437 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5440 "process_numa_paired_threads",
5441 new_callable
=CopyingMock(),
5443 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5444 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5445 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_vio(
5447 mock_process_numa_threads
,
5448 mock_process_numa_cores
,
5449 mock_process_numa_paired_threads
,
5450 mock_process_numa_vcpu
,
5451 mock_process_numa_memory
,
5452 mock_process_vio_numa_nodes
,
5454 """Process numa parameters, id, cores exist, vim type is VIO.
5455 vcpus calculation according to cores in numa.
5457 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5459 expected_extra_specs
= {
5460 "hw:cpu_cores": "3",
5461 "hw:cpu_sockets": "2",
5462 "hw:numa_nodes": "2",
5464 self
.vimconn
.vim_type
= "VIO"
5465 mock_process_numa_cores
.side_effect
= [1, 2]
5466 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5467 check_if_assert_not_called(
5468 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5470 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5471 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5472 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5473 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5474 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5476 _call_mock_process_numa_cores
[0].args
,
5478 {"id": 0, "cores": 1},
5480 "hw:cpu_sockets": "2",
5481 "hw:numa_nodes": "2",
5486 _call_mock_process_numa_cores
[1].args
,
5488 {"id": 1, "cores": 2},
5490 "hw:cpu_sockets": "2",
5491 "hw:numa_nodes": "2",
5495 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5497 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5498 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5499 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5502 "process_numa_paired_threads",
5503 new_callable
=CopyingMock(),
5505 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5506 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5507 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_vio(
5509 mock_process_numa_threads
,
5510 mock_process_numa_cores
,
5511 mock_process_numa_paired_threads
,
5512 mock_process_numa_vcpu
,
5513 mock_process_numa_memory
,
5514 mock_process_vio_numa_nodes
,
5516 """Process numa parameters, memory, vcpu, thread exist, vim type is VIO,
5517 vcpus calculation according threads in numa, there are not numa ids.
5520 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5521 {"memory": 2, "vcpu": [2]},
5524 expected_extra_specs
= {
5525 "hw:numa_nodes": "2",
5526 "hw:cpu_sockets": "2",
5527 "hw:cpu_threads": "3",
5529 self
.vimconn
.vim_type
= "VIO"
5530 mock_process_numa_threads
.return_value
= 3
5531 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5532 check_if_assert_not_called(
5534 mock_process_numa_memory
,
5535 mock_process_numa_vcpu
,
5536 mock_process_numa_cores
,
5537 mock_process_numa_paired_threads
,
5540 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5541 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5542 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5544 _call_mock_process_numa_threads
[0].args
,
5546 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5548 "hw:cpu_sockets": "2",
5549 "hw:numa_nodes": "2",
5553 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5555 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5556 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5557 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5560 "process_numa_paired_threads",
5561 new_callable
=CopyingMock(autospec
=True),
5563 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5564 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5565 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_openstack(
5567 mock_process_numa_threads
,
5568 mock_process_numa_cores
,
5569 mock_process_numa_paired_threads
,
5570 mock_process_numa_vcpu
,
5571 mock_process_numa_memory
,
5572 mock_process_vio_numa_nodes
,
5574 """Process numa parameters, memory, vcpu, thread exist, vim type is openstack,
5575 vcpus calculation according threads in numa, there are not numa ids.
5578 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5579 {"memory": 2, "vcpu": [2]},
5582 expected_extra_specs
= {
5583 "hw:numa_nodes": "2",
5584 "hw:cpu_sockets": "2",
5585 "hw:cpu_threads": "3",
5587 self
.vimconn
.vim_type
= "openstack"
5588 mock_process_numa_threads
.return_value
= 3
5589 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5591 check_if_assert_not_called(
5593 mock_process_numa_memory
,
5594 mock_process_numa_vcpu
,
5595 mock_process_numa_cores
,
5596 mock_process_numa_paired_threads
,
5597 mock_process_vio_numa_nodes
,
5600 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5601 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5603 _call_mock_process_numa_threads
[0].args
,
5605 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5606 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5609 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5611 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5612 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5613 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5616 "process_numa_paired_threads",
5617 new_callable
=CopyingMock(),
5619 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5620 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5621 def test_process_numa_parameters_of_flavor_empty_numas_list_type_vio(
5623 mock_process_numa_threads
,
5624 mock_process_numa_cores
,
5625 mock_process_numa_paired_threads
,
5626 mock_process_numa_vcpu
,
5627 mock_process_numa_memory
,
5628 mock_process_vio_numa_nodes
,
5630 """Numa list is empty, vim type is VIO."""
5633 expected_extra_specs
= {"hw:numa_nodes": "0"}
5634 self
.vimconn
.vim_type
= "VIO"
5635 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5636 check_if_assert_not_called(
5638 mock_process_numa_memory
,
5639 mock_process_numa_vcpu
,
5640 mock_process_numa_cores
,
5641 mock_process_numa_paired_threads
,
5642 mock_process_numa_threads
,
5645 mock_process_vio_numa_nodes
.assert_called_once_with(0, {"hw:numa_nodes": "0"})
5646 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5648 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5649 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5650 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5653 "process_numa_paired_threads",
5654 new_callable
=CopyingMock(),
5656 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5657 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5658 def test_process_numa_parameters_of_flavor_empty_numas_list_type_openstack(
5660 mock_process_numa_threads
,
5661 mock_process_numa_cores
,
5662 mock_process_numa_paired_threads
,
5663 mock_process_numa_vcpu
,
5664 mock_process_numa_memory
,
5665 mock_process_vio_numa_nodes
,
5667 """Numa list is empty, vim type is openstack."""
5670 expected_extra_specs
= {"hw:numa_nodes": "0"}
5671 self
.vimconn
.vim_type
= "openstack"
5672 mock_process_numa_threads
.return_value
= None
5673 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5675 check_if_assert_not_called(
5677 mock_process_numa_memory
,
5678 mock_process_numa_vcpu
,
5679 mock_process_numa_cores
,
5680 mock_process_numa_paired_threads
,
5681 mock_process_numa_threads
,
5682 mock_process_vio_numa_nodes
,
5685 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5687 def test_process_numa_memory_empty_extra_spec(self
):
5688 numa
= {"memory": 2, "vcpu": [2]}
5691 expected_extra_spec
= {"hw:numa_mem.2": 2048}
5692 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5693 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5695 def test_process_numa_memory_not_exist(self
):
5696 numa
= {"vcpu": [2]}
5698 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5699 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5700 self
.assertDictEqual(extra_specs
, {"vmware:latency_sensitivity_level": "high"})
5702 def test_process_numa_memory_node_id_is_none(self
):
5703 numa
= {"memory": 2, "vcpu": [2]}
5706 expected_extra_spec
= {"hw:numa_mem.None": 2048}
5707 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5708 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5710 def test_process_numa_vcpu_empty_extra_spec(self
):
5711 numa
= {"vcpu": [2]}
5714 expected_extra_spec
= {"hw:numa_cpus.0": "2"}
5715 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5716 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5718 def test_process_numa_vcpu_not_exist(self
):
5719 numa
= {"memory": 2}
5721 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5722 expected_extra_spec
= {"vmware:latency_sensitivity_level": "high"}
5723 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5724 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5726 def test_process_numa_vcpu_empty_node_id(self
):
5727 numa
= {"vcpu": [2]}
5730 expected_extra_spec
= {"hw:numa_cpus.": "2"}
5731 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5732 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5734 def test_process_numa_vcpu_empty_numa_dict(self
):
5738 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5739 self
.assertDictEqual(extra_specs
, {})
5741 def test_process_numa_vcpu_str_node_id(self
):
5742 numa
= {"vcpu": [2]}
5745 expected_extra_spec
= {"hw:numa_cpus.12": "2"}
5746 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5747 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5749 def test_process_numa_paired_threads_empty_extra_spec(self
):
5750 numa
= {"id": 0, "paired-threads": 3}
5752 expected_extra_spec
= {
5753 "hw:cpu_thread_policy": "require",
5754 "hw:cpu_policy": "dedicated",
5756 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5757 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5758 self
.assertEqual(result
, 6)
5760 def test_process_numa_paired_threads_empty_numa(self
):
5763 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5764 self
.assertDictEqual(extra_specs
, {})
5765 self
.assertEqual(result
, None)
5767 def test_process_numa_paired_threads_not_exist(self
):
5768 numa
= {"vcpu": [2]}
5770 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5771 self
.assertDictEqual(extra_specs
, {})
5772 self
.assertEqual(result
, None)
5774 def test_process_numa_paired_threads_str_thread_num(self
):
5775 numa
= {"id": 0, "paired-threads": "3"}
5777 expected_extra_spec
= {
5778 "hw:cpu_thread_policy": "require",
5779 "hw:cpu_policy": "dedicated",
5781 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5782 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5783 self
.assertEqual(result
, "33")
5785 def test_process_numa_paired_threads_none_thread_num(self
):
5786 numa
= {"id": 0, "paired-threads": None}
5788 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5789 self
.assertDictEqual(extra_specs
, {})
5790 self
.assertEqual(result
, None)
5792 def test_process_numa_cores_empty_extra_spec(self
):
5793 numa
= {"id": 0, "cores": 1}
5795 expected_extra_spec
= {
5796 "hw:cpu_policy": "dedicated",
5797 "hw:cpu_thread_policy": "isolate",
5799 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5800 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5801 self
.assertEqual(result
, 1)
5803 def test_process_numa_cores_not_exist(self
):
5804 numa
= {"id": 0, "paired-threads": 3}
5806 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5807 self
.assertDictEqual(extra_specs
, {})
5808 self
.assertEqual(result
, None)
5810 def test_process_numa_cores_empty_numa(self
):
5812 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5813 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5814 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5815 self
.assertEqual(result
, None)
5817 def test_process_numa_cores_none_core_num(self
):
5818 numa
= {"memory": 1, "cores": None}
5820 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5821 self
.assertDictEqual(extra_specs
, {})
5822 self
.assertEqual(result
, None)
5824 def test_process_numa_cores_string_core_num(self
):
5825 numa
= {"id": 0, "cores": "1"}
5826 extra_specs
= {"some-key": "some-val"}
5827 expected_extra_spec
= {
5828 "hw:cpu_policy": "dedicated",
5829 "hw:cpu_thread_policy": "isolate",
5830 "some-key": "some-val",
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_float_core_num(self
):
5837 numa
= {"memory": 2, "cores": 10.03}
5838 extra_specs
= {"some-key": "some-val"}
5839 expected_extra_spec
= {
5840 "hw:cpu_policy": "dedicated",
5841 "hw:cpu_thread_policy": "isolate",
5842 "some-key": "some-val",
5844 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5845 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5846 self
.assertEqual(result
, 10.03)
5848 def test_process_numa_threads_empty_extra_spec_int_thread_num(self
):
5849 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3}
5851 expected_extra_spec
= {
5852 "hw:cpu_policy": "dedicated",
5853 "hw:cpu_thread_policy": "prefer",
5855 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5856 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5857 self
.assertEqual(result
, 3)
5859 def test_process_numa_threads_empty_numa(self
):
5861 extra_specs
= {"some-key": "some-val"}
5862 expected_extra_spec
= {"some-key": "some-val"}
5863 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5864 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5865 self
.assertEqual(result
, None)
5867 def test_process_numa_threads_not_exist(self
):
5868 numa
= {"memory": 1}
5869 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5870 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5871 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5872 self
.assertEqual(result
, None)
5874 def test_process_numa_threads_str_thread_num(self
):
5875 numa
= {"vcpu": [1, 3], "threads": "3"}
5877 expected_extra_spec
= {
5878 "hw:cpu_policy": "dedicated",
5879 "hw:cpu_thread_policy": "prefer",
5881 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5882 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5883 self
.assertEqual(result
, "3")
5885 def test_process_numa_threads_none_thread_num(self
):
5886 numa
= {"vcpu": [1, 3], "threads": None}
5888 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5889 self
.assertDictEqual(extra_specs
, {})
5890 self
.assertEqual(result
, None)
5892 def test_process_numa_threads_float_thread_num(self
):
5893 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3.3}
5894 extra_specs
= {"some-key": "some-val"}
5895 expected_extra_spec
= {
5896 "hw:cpu_policy": "dedicated",
5897 "hw:cpu_thread_policy": "prefer",
5898 "some-key": "some-val",
5900 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5901 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5902 self
.assertEqual(result
, 3.3)
5904 def test_change_the_flavor_name_not_existing_name(self
):
5905 """Flavor name does not exist in Openstack flavor list."""
5906 self
.flavor1
.name
= "sample-flavor-3"
5907 self
.flavor2
.name
= "other-flavor-4"
5908 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5909 name
= "other-flavor-3"
5911 flavor_data
= {"name": "other-flavor"}
5912 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5913 self
.assertEqual(result
, name
)
5914 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5915 # Checking whether name_suffix changed or not.
5916 self
.assertEqual(name_suffix
, 3)
5918 def test_change_the_flavor_name_existing_name(self
):
5919 """Flavor name exists in Openstack flavor list."""
5920 self
.flavor1
.name
= "other-flavor-6"
5921 self
.flavor2
.name
= "other-flavor-3"
5922 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5923 name
= "other-flavor-3"
5925 flavor_data
= {"name": "other-flavor"}
5926 expected_result
= "other-flavor-7"
5927 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5928 self
.assertEqual(result
, expected_result
)
5929 # Checking whether name_suffix changed or not.
5930 self
.assertEqual(name_suffix
, 5)
5931 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5933 def test_change_the_flavor_name_flavor_data_does_not_have_name(self
):
5934 """Flavor data does not have name."""
5935 self
.flavor1
.name
= "other-flavor-6"
5936 self
.flavor2
.name
= "other-flavor-3"
5937 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5938 name
= "other-flavor-3"
5941 with self
.assertRaises(KeyError):
5942 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5943 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5944 # Checking whether name_suffix changed or not.
5945 self
.assertEqual(name_suffix
, 5)
5947 def test_change_the_flavor_name_invalid_name_suffix(self
):
5948 """Name suffix is invalid."""
5949 self
.flavor1
.name
= "other-flavor-6"
5950 self
.flavor2
.name
= "other-flavor-3"
5951 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5952 name
= "other-flavor-3"
5954 flavor_data
= {"name": "other-flavor"}
5955 with self
.assertRaises(TypeError):
5956 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5957 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5958 # Checking whether name_suffix changed or not.
5959 self
.assertEqual(name_suffix
, "a")
5961 def test_change_the_flavor_name_given_name_is_empty(self
):
5962 """Given name is empty string."""
5963 self
.flavor1
.name
= "other-flavor-6"
5964 self
.flavor2
.name
= "other-flavor-3"
5965 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5968 flavor_data
= {"name": "other-flavor"}
5969 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5970 self
.assertEqual(result
, "")
5971 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5972 # Checking whether name_suffix increased or not.
5973 self
.assertEqual(name_suffix
, 3)
5975 def test_change_the_flavor_name_given_name_is_none(self
):
5976 """Given name is None."""
5977 self
.flavor1
.name
= "other-flavor-6"
5978 self
.flavor2
.name
= "other-flavor-3"
5979 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5982 flavor_data
= {"name": "other-flavor"}
5983 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5984 self
.assertEqual(result
, None)
5985 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5986 # Checking whether name_suffix increased or not.
5987 self
.assertEqual(name_suffix
, 6)
5989 def test_change_the_flavor_name_empty_nova_flavor_list(self
):
5990 """Nova flavor list is empty."""
5991 self
.vimconn
.nova
.flavors
.list.return_value
= []
5992 name
= "other-flavor-3"
5994 flavor_data
= {"name": "other-flavor"}
5995 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5996 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5997 self
.assertEqual(result
, name
)
5998 # Checking whether name_suffix increased or not.
5999 self
.assertEqual(name_suffix
, 5)
6003 "_process_numa_parameters_of_flavor",
6004 new_callable
=CopyingMock(),
6006 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6007 def test_process_extended_config_of_flavor_with_numa_cpu_mem_vif_disk_quota(
6008 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6010 """Process extended config, extended has numas, cpu, mem, vif and disk-io quota."""
6012 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6013 {"memory": 2, "vcpu": [2]},
6017 "cpu-quota": {"limit": 3},
6018 "mem-quota": {"limit": 1},
6019 "vif-quota": {"limit": 10},
6020 "disk-io-quota": {"limit": 50},
6021 "mempage-size": "LARGE",
6024 expected_extra_specs
= {
6025 "hw:mem_page_size": "large",
6027 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6029 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6030 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6031 self
.assertEqual(extra_specs
, expected_extra_specs
)
6035 "_process_numa_parameters_of_flavor",
6036 new_callable
=CopyingMock(),
6038 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6039 def test_process_extended_config_of_flavor_with_numa_wrong_disk_quota(
6040 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6042 """Process extended config, extended has wrong disk quota key."""
6044 {"memory": 1, "threads": 3},
6045 {"memory": 2, "vcpu": [2]},
6049 "disk-quota": {"limit": 50},
6050 "mempage-size": "PREFER_LARGE",
6053 expected_extra_specs
= {
6054 "hw:mem_page_size": "any",
6056 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6057 mock_process_resource_quota
.assert_not_called()
6058 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6059 self
.assertEqual(extra_specs
, expected_extra_specs
)
6063 "_process_numa_parameters_of_flavor",
6064 new_callable
=CopyingMock(),
6066 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6067 def test_process_extended_config_of_flavor_without_numa_cpu_mem_vif_disk_quota(
6068 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6070 """Process extended config, extended has cpu, mem, vif and disk-io quota but not numas."""
6072 "cpu-quota": {"limit": 3},
6073 "mem-quota": {"limit": 1},
6074 "vif-quota": {"limit": 10},
6075 "disk-io-quota": {"limit": 50},
6076 "mempage-size": "SMALL",
6079 expected_extra_specs
= {
6080 "hw:mem_page_size": "small",
6082 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6083 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6084 mock_process_numa_parameters_of_flavor
.assert_not_called()
6085 self
.assertEqual(extra_specs
, expected_extra_specs
)
6089 "_process_numa_parameters_of_flavor",
6090 new_callable
=CopyingMock(),
6092 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6093 def test_process_extended_config_of_flavor_with_numa_with_cpu_pinning_mem_policy(
6094 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6096 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy."""
6099 {"memory": 2, "vcpu": [2]},
6103 "cpu-quota": {"limit": 3},
6104 "mem-quota": {"limit": 1},
6105 "mempage-size": "LARGE",
6106 "cpu-pinning-policy": "DEDICATED",
6107 "mem-policy": "STRICT",
6110 expected_extra_specs
= {
6111 "hw:mem_page_size": "large",
6112 "hw:cpu_policy": "dedicated",
6113 "hw:numa_mempolicy": "strict",
6115 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6116 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6117 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
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_without_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 but not numas."""
6131 "cpu-quota": {"limit": 3},
6132 "mem-quota": {"limit": 1},
6133 "mempage-size": "LARGE",
6134 "cpu-pinning-policy": "DEDICATED",
6135 "mem-policy": "STRICT",
6138 expected_extra_specs
= {
6139 "hw:mem_page_size": "large",
6140 "hw:cpu_policy": "dedicated",
6141 "hw:numa_mempolicy": "strict",
6143 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6144 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6145 mock_process_numa_parameters_of_flavor
.assert_not_called()
6146 self
.assertEqual(extra_specs
, expected_extra_specs
)
6150 "_process_numa_parameters_of_flavor",
6151 new_callable
=CopyingMock(),
6153 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6154 def test_process_extended_config_of_flavor_without_numa_with_wrong_mempage_size(
6155 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6157 """Process extended config, extended has wrong mempage-size without numas."""
6159 "cpu-quota": {"limit": 3},
6160 "mem-quota": {"limit": 1},
6161 "mempage-size": "SIZE_2GB",
6162 "cpu-pinning-policy": "DEDICATED",
6163 "mem-policy": "STRICT",
6167 expected_extra_specs
= {
6168 "hw:cpu_policy": "dedicated",
6169 "hw:numa_mempolicy": "strict",
6171 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6172 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6173 mock_process_numa_parameters_of_flavor
.assert_not_called()
6174 self
.assertEqual(extra_specs
, expected_extra_specs
)
6178 "_process_numa_parameters_of_flavor",
6179 new_callable
=CopyingMock(),
6181 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6182 def test_process_extended_config_of_flavor_with_numa_with_wrong_mempage_size(
6183 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6185 """Process extended config, extended has wrong mempage-size with numas."""
6188 {"memory": 2, "vcpu": [2]},
6192 "cpu-quota": {"limit": 3},
6193 "mem-quota": {"limit": 1},
6194 "mempage-size": "SIZE_2GB",
6195 "cpu-pinning-policy": "DEDICATED",
6196 "mem-policy": "STRICT",
6199 expected_extra_specs
= {
6200 "hw:cpu_policy": "dedicated",
6201 "hw:numa_mempolicy": "strict",
6203 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6204 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6205 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6206 self
.assertEqual(extra_specs
, expected_extra_specs
)
6210 "_process_numa_parameters_of_flavor",
6211 new_callable
=CopyingMock(),
6213 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6214 def test_process_extended_config_of_flavor_none_vcpus(
6215 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6217 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6220 {"memory": 2, "vcpu": [2]},
6224 "cpu-quota": {"limit": 3},
6225 "mem-quota": {"limit": 1},
6226 "mempage-size": "SIZE_2GB",
6227 "cpu-pinning-policy": "DEDICATED",
6228 "mem-policy": "STRICT",
6231 expected_extra_specs
= {
6232 "hw:cpu_policy": "dedicated",
6233 "hw:numa_mempolicy": "strict",
6235 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6236 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6237 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6238 self
.assertEqual(extra_specs
, expected_extra_specs
)
6242 "_process_numa_parameters_of_flavor",
6243 new_callable
=CopyingMock(),
6245 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6246 def test_process_extended_config_of_flavor_none_vcpus_without_numas(
6247 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6249 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6251 "cpu-quota": {"limit": 3},
6252 "mem-quota": {"limit": 1},
6253 "mempage-size": "SIZE_2GB",
6254 "cpu-pinning-policy": "DEDICATED",
6255 "mem-policy": "STRICT",
6257 extra_specs
= {"some-key": "some-val"}
6258 expected_extra_specs
= {
6259 "hw:cpu_policy": "dedicated",
6260 "hw:numa_mempolicy": "strict",
6261 "some-key": "some-val",
6263 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6264 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6265 mock_process_numa_parameters_of_flavor
.assert_not_called()
6266 self
.assertEqual(extra_specs
, expected_extra_specs
)
6270 "_process_numa_parameters_of_flavor",
6271 new_callable
=CopyingMock(),
6273 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6274 def test_process_extended_config_of_flavor_wrong_cpu_pinning_mem_policy_empty_vcpus(
6275 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6277 """Process extended config, extended has wrong cpu-pinning and mem-policy keys."""
6280 {"memory": 2, "vcpu": [2]},
6284 "cpu-quota": {"limit": 3},
6285 "mem-quota": {"limit": 1},
6286 "mempage-size": "SIZE_2GB",
6287 "cpu-pinning-pol": "DEDICATED",
6288 "mem-pol": "STRICT",
6291 expected_extra_specs
= {}
6292 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6293 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6294 mock_process_numa_parameters_of_flavor
.assert_called_once_with(
6297 self
.assertEqual(extra_specs
, expected_extra_specs
)
6301 "_process_numa_parameters_of_flavor",
6302 new_callable
=CopyingMock(),
6304 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6305 def test_process_extended_config_of_flavor_empty_extended(
6306 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6308 """Process extended config, extended is empty."""
6311 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6312 check_if_assert_not_called(
6313 [mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
]
6315 self
.assertEqual(extra_specs
, {})
6317 def test_get_flavor_details_empty_flavor_data(self
):
6319 expected_result
= (64, 1, {}, None)
6320 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6321 self
.assertEqual(result
, expected_result
)
6323 def test_get_flavor_details_flavor_data_has_ram_vcpus_extended(self
):
6328 "some-key": "some-val",
6331 expected_result
= (32, 3, {}, {"some-key": "some-val"})
6332 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6333 self
.assertEqual(result
, expected_result
)
6335 def test_get_flavor_details_flavor_data_is_none(self
):
6337 with self
.assertRaises(AttributeError):
6338 self
.vimconn
._get
_flavor
_details
(flavor_data
)
6340 def test_get_flavor_details_flavor_data_has_only_extended(self
):
6343 "some-key": "some-val",
6346 expected_result
= (64, 1, {}, {"some-key": "some-val"})
6347 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6348 self
.assertEqual(result
, expected_result
)
6350 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6353 "_process_extended_config_of_flavor",
6354 new_callable
=CopyingMock(),
6356 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6357 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6358 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6359 def test_new_flavor_with_extended_with_extra_specs(
6361 mock_format_exception
,
6362 mock_reload_connection
,
6363 mock_change_flavor_name
,
6364 mock_extended_config_of_flavor
,
6365 mock_get_flavor_details
,
6367 """Create new flavor with using extended parameters and extra specs."""
6370 mock_change_flavor_name
.return_value
= name1
6371 mock_get_flavor_details
.return_value
= (
6374 {"some-key": "some-value"},
6377 expected_result
= self
.new_flavor
.id
6378 result
= self
.vimconn
.new_flavor(flavor_data
)
6379 self
.assertEqual(result
, expected_result
)
6380 mock_reload_connection
.assert_called_once()
6381 self
.new_flavor
.set_keys
.assert_called_once()
6382 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6383 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6384 mock_extended_config_of_flavor
.assert_called_once_with(
6385 extended
, {"some-key": "some-value"}
6387 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6388 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6390 mock_format_exception
.assert_not_called()
6392 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6395 "_process_extended_config_of_flavor",
6396 new_callable
=CopyingMock(),
6398 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6399 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6400 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6401 def test_new_flavor_with_extended_without_extra_specs(
6403 mock_format_exception
,
6404 mock_reload_connection
,
6405 mock_change_flavor_name
,
6406 mock_extended_config_of_flavor
,
6407 mock_get_flavor_details
,
6409 """Create new flavor with using extended parameters without extra specs."""
6412 mock_change_flavor_name
.return_value
= name1
6413 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6414 expected_result
= self
.new_flavor
.id
6415 result
= self
.vimconn
.new_flavor(flavor_data
)
6416 self
.assertEqual(result
, expected_result
)
6417 mock_reload_connection
.assert_called_once()
6418 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6419 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6420 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6421 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6422 name
=name1
, ram
=3, vcpus
=vcpus
, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6424 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6426 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6429 "_process_extended_config_of_flavor",
6430 new_callable
=CopyingMock(),
6432 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6433 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6434 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6435 def test_new_flavor_change_name_if_used_false_with_extended(
6437 mock_format_exception
,
6438 mock_reload_connection
,
6439 mock_change_flavor_name
,
6440 mock_extended_config_of_flavor
,
6441 mock_get_flavor_details
,
6443 """Create new flavor, change_name_if_used_false, there is extended."""
6445 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6446 expected_result
= self
.new_flavor
.id
6447 result
= self
.vimconn
.new_flavor(flavor_data
, False)
6448 self
.assertEqual(result
, expected_result
)
6449 mock_reload_connection
.assert_called_once()
6450 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6451 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6452 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6453 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6455 check_if_assert_not_called(
6456 [mock_change_flavor_name
, mock_format_exception
, self
.new_flavor
.set_keys
]
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_true_without_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 without extended parameters."""
6478 mock_change_flavor_name
.return_value
= name1
6479 expected_result
= self
.new_flavor
.id
6480 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6481 result
= self
.vimconn
.new_flavor(flavor_data2
)
6482 self
.assertEqual(result
, expected_result
)
6483 mock_reload_connection
.assert_called_once()
6484 mock_change_flavor_name
.assert_called_once_with(
6485 name1
, name_suffix
, flavor_data2
6487 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6488 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6489 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6491 check_if_assert_not_called(
6493 self
.new_flavor
.set_keys
,
6494 mock_extended_config_of_flavor
,
6495 mock_format_exception
,
6499 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6502 "_process_extended_config_of_flavor",
6503 new_callable
=CopyingMock(),
6505 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6506 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6507 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6508 def test_new_flavor_reload_connection_exception(
6510 mock_format_exception
,
6511 mock_reload_connection
,
6512 mock_change_flavor_name
,
6513 mock_extended_config_of_flavor
,
6514 mock_get_flavor_details
,
6516 """Create new flavor, reload connection exception occurred."""
6517 error_msg
= "Can not connect to client APIs."
6518 error
= nvExceptions
.ClientException(error_msg
)
6519 mock_change_flavor_name
.return_value
= name1
6520 mock_reload_connection
.side_effect
= error
6521 with self
.assertRaises(Exception) as err
:
6522 self
.vimconn
.new_flavor(flavor_data2
)
6523 self
.assertEqual(str(err
.exception
), "Can not connect to client APIs.")
6524 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6525 call_mock_format_exception
= mock_format_exception
.call_args
6527 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6529 check_if_assert_not_called(
6531 mock_change_flavor_name
,
6532 mock_get_flavor_details
,
6533 mock_extended_config_of_flavor
,
6534 self
.vimconn
.nova
.flavors
.create
,
6538 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6541 "_process_extended_config_of_flavor",
6542 new_callable
=CopyingMock(autospec
=True),
6544 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6545 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6546 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6547 def test_new_flavor_flavor_data_without_name(
6549 mock_format_exception
,
6550 mock_reload_connection
,
6551 mock_change_flavor_name
,
6552 mock_extended_config_of_flavor
,
6553 mock_get_flavor_details
,
6555 """Create new flavor, flavor data does not have name."""
6562 self
.vimconn
.new_flavor(flavor_data3
)
6563 mock_format_exception
.assert_called_once()
6564 call_mock_format_exception
= mock_format_exception
.call_args
6566 str(call_mock_format_exception
[0][0]), str(KeyError(error_msg
))
6568 check_if_assert_not_called(
6570 mock_reload_connection
,
6571 mock_change_flavor_name
,
6572 mock_get_flavor_details
,
6573 mock_extended_config_of_flavor
,
6574 self
.vimconn
.nova
.flavors
.create
,
6578 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6581 "_process_extended_config_of_flavor",
6582 new_callable
=CopyingMock(),
6584 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6585 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6586 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6587 def test_new_flavor_change_flavor_name_has_extended_conflict_exception_recovered_in_retry(
6589 mock_format_exception
,
6590 mock_reload_connection
,
6591 mock_change_flavor_name
,
6592 mock_extended_config_of_flavor
,
6593 mock_get_flavor_details
,
6595 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is extended config."""
6597 error_msg
= "Conflict has occurred while creating flavor name."
6598 error2
= nvExceptions
.Conflict(error_msg
)
6599 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6600 expected_result
= self
.new_flavor
.id
6601 mock_get_flavor_details
.return_value
= (3, 8, {}, extended
)
6602 result
= self
.vimconn
.new_flavor(flavor_data2
)
6603 self
.assertEqual(result
, expected_result
)
6604 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6605 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6606 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6607 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6608 self
.assertEqual(mock_extended_config_of_flavor
.call_count
, 1)
6609 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6610 name
="sample-flavor-3",
6618 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6620 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6623 "_process_extended_config_of_flavor",
6624 new_callable
=CopyingMock(),
6626 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6627 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6628 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6629 def test_new_flavor_change_flavor_name_without_extended_conflict_exception_recovered_in_retry(
6631 mock_format_exception
,
6632 mock_reload_connection
,
6633 mock_change_flavor_name
,
6634 mock_extended_config_of_flavor
,
6635 mock_get_flavor_details
,
6637 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is not extended config."""
6639 error2
= nvExceptions
.Conflict(
6640 "Conflict has occurred while creating flavor name."
6642 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6643 expected_result
= self
.new_flavor
.id
6644 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6645 result
= self
.vimconn
.new_flavor(flavor_data2
)
6646 self
.assertEqual(result
, expected_result
)
6647 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6648 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6649 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6650 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6651 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6652 name
="sample-flavor-3",
6660 check_if_assert_not_called(
6662 self
.new_flavor
.set_keys
,
6663 mock_extended_config_of_flavor
,
6664 mock_format_exception
,
6668 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6671 "_process_extended_config_of_flavor",
6672 new_callable
=CopyingMock(),
6674 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6675 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6676 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6677 def test_new_flavor_change_flavor_name_conflict_exception_change_name_if_used_false(
6679 mock_format_exception
,
6680 mock_reload_connection
,
6681 mock_change_flavor_name
,
6682 mock_extended_config_of_flavor
,
6683 mock_get_flavor_details
,
6685 """Create new flavor, nvExceptions.Conflict occurred,
6686 change_name_if_used is false."""
6687 change_name_if_used
= False
6688 error_msg
= "Conflict has occurred while creating flavor name."
6689 error2
= nvExceptions
.Conflict(error_msg
)
6690 mock_get_flavor_details
.return_value
= (4, 8, {}, None)
6691 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6692 with self
.assertRaises(Exception) as err
:
6693 self
.vimconn
.new_flavor(flavor_data2
, change_name_if_used
)
6694 self
.assertEqual(str(err
.exception
), error_msg
)
6695 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6696 self
.vimconn
.nova
.flavors
.create
.assert_called_with(
6697 name
="sample-flavor",
6705 self
.assertEqual(mock_get_flavor_details
.call_count
, 3)
6706 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6707 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6708 check_if_assert_not_called(
6709 [mock_change_flavor_name
, mock_extended_config_of_flavor
]
6711 _call_mock_format_exception
= mock_format_exception
.call_args
6713 str(_call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6715 self
.assertEqual(mock_format_exception
.call_count
, 3)
6717 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6720 "_process_extended_config_of_flavor",
6721 new_callable
=CopyingMock(),
6723 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6724 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6725 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6726 def test_new_flavor_client_exception_occurred_change_name_if_used_true(
6728 mock_format_exception
,
6729 mock_reload_connection
,
6730 mock_change_flavor_name
,
6731 mock_extended_config_of_flavor
,
6732 mock_get_flavor_details
,
6734 """Create new flavor, nvExceptions.ClientException occurred,
6735 change_name_if_used is true."""
6736 error_msg
= "Connection failed."
6737 error2
= nvExceptions
.ClientException(error_msg
)
6738 mock_change_flavor_name
.side_effect
= [
6743 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6744 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6745 with self
.assertRaises(Exception) as err
:
6746 self
.vimconn
.new_flavor(flavor_data2
)
6748 str(err
.exception
), "Conflict has occurred while creating flavor name."
6750 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6751 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 1)
6752 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6754 _call_mock_nova_create_flavor
[0][1],
6757 "name": "sample-flavor-3",
6768 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6769 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6770 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6772 _call_mock_change_flavor
[0][0],
6776 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6779 self
.assertEqual(mock_change_flavor_name
.call_count
, 1)
6780 mock_extended_config_of_flavor
.assert_not_called()
6781 call_mock_format_exception
= mock_format_exception
.call_args
6783 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6785 self
.assertEqual(mock_format_exception
.call_count
, 1)
6787 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6790 "_process_extended_config_of_flavor",
6791 new_callable
=CopyingMock(),
6793 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6794 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6795 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6796 def test_new_flavor_change_flavor_name_conflict_exception_occurred_change_name_if_used_true(
6798 mock_format_exception
,
6799 mock_reload_connection
,
6800 mock_change_flavor_name
,
6801 mock_extended_config_of_flavor
,
6802 mock_get_flavor_details
,
6804 """Create new flavor, nvExceptions.Conflict occurred,
6805 change_name_if_used is true."""
6806 error_msg
= "Conflict has occurred while creating flavor name."
6807 error2
= nvExceptions
.Conflict(error_msg
)
6808 mock_change_flavor_name
.side_effect
= [
6813 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6814 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6815 with self
.assertRaises(Exception) as err
:
6816 self
.vimconn
.new_flavor(flavor_data2
)
6817 self
.assertEqual(str(err
.exception
), error_msg
)
6818 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6819 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6820 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6822 _call_mock_nova_create_flavor
[0][1],
6825 "name": "sample-flavor-3",
6836 _call_mock_nova_create_flavor
[1][1],
6839 "name": "sample-flavor-4",
6850 _call_mock_nova_create_flavor
[2][1],
6853 "name": "sample-flavor-5",
6863 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6864 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6866 _call_mock_change_flavor
[0][0],
6870 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6874 _call_mock_change_flavor
[1][0],
6878 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6882 _call_mock_change_flavor
[2][0],
6886 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6889 self
.assertEqual(mock_change_flavor_name
.call_count
, 3)
6890 mock_extended_config_of_flavor
.assert_not_called()
6891 call_mock_format_exception
= mock_format_exception
.call_args
6893 str(call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6895 self
.assertEqual(mock_format_exception
.call_count
, 1)
6897 def test_process_process_vio_numa_nodes_without_numa_with_extra_spec(self
):
6899 extra_specs
= {"hw:numa_nodes": "0"}
6900 expected_extra_spec
= {
6901 "vmware:latency_sensitivity_level": "high",
6902 "hw:numa_nodes": "0",
6904 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6905 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6907 def test_process_process_vio_numa_nodes_list_type_numa_nodes_empty_extra_spec(self
):
6908 numa_nodes
= [7, 9, 4]
6910 expected_extra_spec
= {
6911 "vmware:latency_sensitivity_level": "high",
6913 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6914 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6916 def test_process_process_vio_numa_nodes_with_numa_with_extra_spec(self
):
6918 extra_specs
= {"hw:numa_nodes": "5"}
6919 expected_extra_spec
= {
6920 "vmware:latency_sensitivity_level": "high",
6921 "hw:numa_nodes": "5",
6923 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6924 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6926 def test_process_process_vio_numa_nodes_none_numa_nodes(self
):
6928 extra_specs
= {"hw:numa_nodes": "None"}
6929 expected_extra_spec
= {
6930 "vmware:latency_sensitivity_level": "high",
6931 "hw:numa_nodes": "None",
6933 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6934 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6936 def test_process_process_vio_numa_nodes_invalid_type_extra_specs(self
):
6939 with self
.assertRaises(TypeError):
6940 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6943 if __name__
== "__main__":