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
.neutron
.list_ports
.return_value
= {
4145 "ports": [{"id": port_id
}, {"id": port2_id
}]
4148 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4149 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4150 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4151 self
.vimconn
.logger
.error
.assert_not_called()
4153 def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self
):
4154 """port id not in the port list."""
4156 self
.vimconn
.neutron
.list_ports
.return_value
= {
4157 "ports": [{"id": port_id
}, {"id": port2_id
}]
4160 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4161 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4162 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4163 self
.vimconn
.logger
.error
.assert_not_called()
4165 def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self
):
4166 """neutron list port raises exception."""
4168 self
.vimconn
.neutron
.list_ports
.side_effect
= nvExceptions
.ClientException(
4169 "Connection aborted."
4171 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4172 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4173 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4174 self
.vimconn
.logger
.error
.assert_called_once_with(
4175 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4178 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
4179 """neutron delete port raises exception."""
4181 self
.vimconn
.neutron
.list_ports
.return_value
= {
4182 "ports": [{"id": port_id
}, {"id": port2_id
}]
4184 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
4185 "Connection aborted."
4187 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4188 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4189 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4190 self
.vimconn
.logger
.error
.assert_called_once_with(
4191 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4194 def test_get_item_name_id(self
):
4195 """Get name and id successfully."""
4196 k
= f
"some:{port_id}"
4197 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4198 self
.assertEqual(result
, ("some", f
"{port_id}"))
4200 def test_get_item_name_id_wthout_semicolon(self
):
4201 """Does not have seperator."""
4202 k
= f
"some{port_id}"
4203 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4204 self
.assertEqual(result
, (f
"some{port_id}", ""))
4206 def test_get_item_name_id_empty_string(self
):
4209 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4210 self
.assertEqual(result
, ("", ""))
4212 def test_get_item_name_id_k_is_none(self
):
4215 with self
.assertRaises(AttributeError):
4216 self
.vimconn
._get
_item
_name
_id
(k
)
4218 @patch.object(vimconnector
, "_get_item_name_id")
4219 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4220 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4221 def test_delete_created_items(
4223 mock_delete_floating_ip_by_id
,
4224 mock_delete_volumes_by_id_wth_cinder
,
4225 mock_get_item_name_id
,
4227 """Created items has floating ip and volume."""
4229 f
"floating_ip:{floating_network_vim_id}": True,
4230 f
"volume:{volume_id}": True,
4231 f
"port:{port_id}": None,
4233 mock_get_item_name_id
.side_effect
= [
4234 ("floating_ip", f
"{floating_network_vim_id}"),
4235 ("volume", f
"{volume_id}"),
4237 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4238 volumes_to_hold
= []
4239 keep_waiting
= False
4240 result
= self
.vimconn
._delete
_created
_items
(
4241 created_items
, volumes_to_hold
, keep_waiting
4243 self
.assertEqual(result
, True)
4244 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4245 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4246 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4248 mock_delete_floating_ip_by_id
.assert_called_once_with(
4249 f
"floating_ip:{floating_network_vim_id}",
4250 f
"{floating_network_vim_id}",
4253 self
.vimconn
.logger
.error
.assert_not_called()
4255 @patch.object(vimconnector
, "_get_item_name_id")
4256 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4257 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4258 def test_delete_created_items_wth_volumes_to_hold(
4260 mock_delete_floating_ip_by_id
,
4261 mock_delete_volumes_by_id_wth_cinder
,
4262 mock_get_item_name_id
,
4264 """Created items has floating ip and volume and volumes_to_hold has items."""
4266 f
"floating_ip:{floating_network_vim_id}": True,
4267 f
"volume:{volume_id}": True,
4268 f
"port:{port_id}": None,
4270 mock_get_item_name_id
.side_effect
= [
4271 ("floating_ip", f
"{floating_network_vim_id}"),
4272 ("volume", f
"{volume_id}"),
4274 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4275 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4276 keep_waiting
= False
4277 result
= self
.vimconn
._delete
_created
_items
(
4278 created_items
, volumes_to_hold
, keep_waiting
4280 self
.assertEqual(result
, True)
4281 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4282 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4283 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4285 mock_delete_floating_ip_by_id
.assert_called_once_with(
4286 f
"floating_ip:{floating_network_vim_id}",
4287 f
"{floating_network_vim_id}",
4290 self
.vimconn
.logger
.error
.assert_not_called()
4292 @patch.object(vimconnector
, "_get_item_name_id")
4293 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4294 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4295 def test_delete_created_items_wth_keep_waiting_true(
4297 mock_delete_floating_ip_by_id
,
4298 mock_delete_volumes_by_id_wth_cinder
,
4299 mock_get_item_name_id
,
4301 """Keep waiting initial value is True."""
4303 f
"floating_ip:{floating_network_vim_id}": True,
4304 f
"volume:{volume_id}": True,
4305 f
"port:{port_id}": None,
4307 mock_get_item_name_id
.side_effect
= [
4308 ("floating_ip", f
"{floating_network_vim_id}"),
4309 ("volume", f
"{volume_id}"),
4311 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4312 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4314 result
= self
.vimconn
._delete
_created
_items
(
4315 created_items
, volumes_to_hold
, keep_waiting
4317 self
.assertEqual(result
, True)
4318 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4319 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4320 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4322 mock_delete_floating_ip_by_id
.assert_called_once_with(
4323 f
"floating_ip:{floating_network_vim_id}",
4324 f
"{floating_network_vim_id}",
4327 self
.vimconn
.logger
.error
.assert_not_called()
4329 @patch.object(vimconnector
, "_get_item_name_id")
4330 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4331 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4332 def test_delete_created_items_delete_vol_raises(
4334 mock_delete_floating_ip_by_id
,
4335 mock_delete_volumes_by_id_wth_cinder
,
4336 mock_get_item_name_id
,
4338 """Delete volume raises exception."""
4340 f
"floating_ip:{floating_network_vim_id}": True,
4341 f
"volume:{volume_id}": True,
4342 f
"port:{port_id}": None,
4344 mock_get_item_name_id
.side_effect
= [
4345 ("floating_ip", f
"{floating_network_vim_id}"),
4346 ("volume", f
"{volume_id}"),
4348 mock_delete_volumes_by_id_wth_cinder
.side_effect
= ConnectionError(
4349 "Connection failed."
4351 volumes_to_hold
= []
4352 keep_waiting
= False
4353 result
= self
.vimconn
._delete
_created
_items
(
4354 created_items
, volumes_to_hold
, keep_waiting
4356 self
.assertEqual(result
, False)
4357 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4358 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4359 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4361 mock_delete_floating_ip_by_id
.assert_called_once_with(
4362 f
"floating_ip:{floating_network_vim_id}",
4363 f
"{floating_network_vim_id}",
4366 self
.vimconn
.logger
.error
.assert_called_once_with(
4367 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
4370 @patch.object(vimconnector
, "_get_item_name_id")
4371 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4372 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4373 def test_delete_created_items_delete_fip_raises(
4375 mock_delete_floating_ip_by_id
,
4376 mock_delete_volumes_by_id_wth_cinder
,
4377 mock_get_item_name_id
,
4379 """Delete floating ip raises exception."""
4381 f
"floating_ip:{floating_network_vim_id}": True,
4382 f
"volume:{volume_id}": True,
4383 f
"port:{port_id}": None,
4385 mock_get_item_name_id
.side_effect
= [
4386 ("floating_ip", f
"{floating_network_vim_id}"),
4387 ("volume", f
"{volume_id}"),
4389 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4390 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
4391 "Connection failed."
4393 volumes_to_hold
= []
4395 result
= self
.vimconn
._delete
_created
_items
(
4396 created_items
, volumes_to_hold
, keep_waiting
4398 self
.assertEqual(result
, True)
4399 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4400 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4401 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4403 mock_delete_floating_ip_by_id
.assert_called_once_with(
4404 f
"floating_ip:{floating_network_vim_id}",
4405 f
"{floating_network_vim_id}",
4408 self
.vimconn
.logger
.error
.assert_called_once_with(
4409 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
4412 @patch.object(vimconnector
, "_get_item_name_id")
4413 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4414 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4415 def test_delete_created_items_get_item_name_raises(
4417 mock_delete_floating_ip_by_id
,
4418 mock_delete_volumes_by_id_wth_cinder
,
4419 mock_get_item_name_id
,
4421 """Get item, name raises exception."""
4424 f
"volume{volume_id}": True,
4425 f
"port:{port_id}": None,
4427 mock_get_item_name_id
.side_effect
= [
4428 TypeError("Invalid Type"),
4429 AttributeError("Invalid attribute"),
4431 volumes_to_hold
= []
4432 keep_waiting
= False
4433 result
= self
.vimconn
._delete
_created
_items
(
4434 created_items
, volumes_to_hold
, keep_waiting
4436 self
.assertEqual(result
, False)
4437 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4438 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4439 mock_delete_floating_ip_by_id
.assert_not_called()
4440 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
4441 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
4444 (f
"Error deleting volume{volume_id}: Invalid attribute",),
4447 @patch.object(vimconnector
, "_get_item_name_id")
4448 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4449 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4450 def test_delete_created_items_no_fip_wth_port(
4452 mock_delete_floating_ip_by_id
,
4453 mock_delete_volumes_by_id_wth_cinder
,
4454 mock_get_item_name_id
,
4456 """Created items has port, does not have floating ip."""
4458 f
"volume:{volume_id}": True,
4459 f
"port:{port_id}": True,
4461 mock_get_item_name_id
.side_effect
= [
4462 ("volume", f
"{volume_id}"),
4463 ("port", f
"{port_id}"),
4465 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
4466 volumes_to_hold
= []
4467 keep_waiting
= False
4468 result
= self
.vimconn
._delete
_created
_items
(
4469 created_items
, volumes_to_hold
, keep_waiting
4471 self
.assertEqual(result
, False)
4472 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4473 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4474 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4476 mock_delete_floating_ip_by_id
.assert_not_called()
4477 self
.vimconn
.logger
.error
.assert_not_called()
4479 @patch.object(vimconnector
, "_get_item_name_id")
4480 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4481 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4482 def test_delete_created_items_no_volume(
4484 mock_delete_floating_ip_by_id
,
4485 mock_delete_volumes_by_id_wth_cinder
,
4486 mock_get_item_name_id
,
4488 """Created items does not have volume."""
4490 f
"floating_ip:{floating_network_vim_id}": True,
4491 f
"port:{port_id}": None,
4493 mock_get_item_name_id
.side_effect
= [
4494 ("floating_ip", f
"{floating_network_vim_id}")
4496 volumes_to_hold
= []
4497 keep_waiting
= False
4498 result
= self
.vimconn
._delete
_created
_items
(
4499 created_items
, volumes_to_hold
, keep_waiting
4501 self
.assertEqual(result
, False)
4502 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
4503 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4504 mock_delete_floating_ip_by_id
.assert_called_once_with(
4505 f
"floating_ip:{floating_network_vim_id}",
4506 f
"{floating_network_vim_id}",
4509 self
.vimconn
.logger
.error
.assert_not_called()
4511 @patch.object(vimconnector
, "_get_item_name_id")
4512 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4513 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4514 def test_delete_created_items_already_deleted(
4516 mock_delete_floating_ip_by_id
,
4517 mock_delete_volumes_by_id_wth_cinder
,
4518 mock_get_item_name_id
,
4520 """All created items are alerady deleted."""
4522 f
"floating_ip:{floating_network_vim_id}": None,
4523 f
"volume:{volume_id}": None,
4524 f
"port:{port_id}": None,
4526 volumes_to_hold
= []
4527 keep_waiting
= False
4528 result
= self
.vimconn
._delete
_created
_items
(
4529 created_items
, volumes_to_hold
, keep_waiting
4531 self
.assertEqual(result
, False)
4532 mock_get_item_name_id
.assert_not_called()
4533 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
4534 mock_delete_floating_ip_by_id
.assert_not_called()
4535 self
.vimconn
.logger
.error
.assert_not_called()
4537 @patch("time.sleep")
4538 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4539 @patch.object(vimconnector
, "_format_exception")
4540 @patch.object(vimconnector
, "_reload_connection")
4541 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4542 @patch.object(vimconnector
, "_delete_created_items")
4543 def test_delete_vminstance_successfully(
4545 mock_delete_created_items
,
4546 mock_delete_vm_ports_attached_to_network
,
4547 mock_reload_connection
,
4548 mock_format_exception
,
4549 mock_extract_items_wth_keep_flag_from_created_items
,
4552 vm_id
= f
"{virtual_mac_id}"
4553 created_items
= deepcopy(created_items_all_true
)
4554 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4555 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4556 mock_delete_created_items
.return_value
= False
4557 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4558 mock_reload_connection
.assert_called_once()
4559 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4560 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4561 mock_delete_created_items
.assert_called_once_with(
4562 created_items
, volumes_to_hold
, False
4564 mock_sleep
.assert_not_called()
4565 mock_format_exception
.assert_not_called()
4566 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4570 @patch("time.sleep")
4571 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4572 @patch.object(vimconnector
, "_format_exception")
4573 @patch.object(vimconnector
, "_reload_connection")
4574 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4575 @patch.object(vimconnector
, "_delete_created_items")
4576 def test_delete_vminstance_created_items_has_keep_flag(
4578 mock_delete_created_items
,
4579 mock_delete_vm_ports_attached_to_network
,
4580 mock_reload_connection
,
4581 mock_format_exception
,
4582 mock_extract_items_wth_keep_flag_from_created_items
,
4585 """Created_items includes items which has keep flag."""
4586 vm_id
= f
"{virtual_mac_id}"
4587 initial_created_items
= {
4588 f
"port{port_id}": True,
4589 f
"floating_ip{floating_network_vim_id}": None,
4590 f
"volume{volume_id}keep": True,
4591 f
"volume{volume_id2}keep": True,
4594 f
"port{port_id}": True,
4595 f
"floating_ip{floating_network_vim_id}": None,
4597 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4598 volumes_to_hold
= []
4599 mock_delete_created_items
.return_value
= False
4600 self
.vimconn
.delete_vminstance(vm_id
, initial_created_items
, volumes_to_hold
)
4601 mock_reload_connection
.assert_called_once()
4602 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4603 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4604 mock_delete_created_items
.assert_called_once_with(
4605 created_items
, volumes_to_hold
, False
4607 mock_sleep
.assert_not_called()
4608 mock_format_exception
.assert_not_called()
4609 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4610 initial_created_items
4613 @patch("time.sleep")
4614 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4615 @patch.object(vimconnector
, "_format_exception")
4616 @patch.object(vimconnector
, "_reload_connection")
4617 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4618 @patch.object(vimconnector
, "_delete_created_items")
4619 def test_delete_vminstance_extract_items_wth_keep_raises(
4621 mock_delete_created_items
,
4622 mock_delete_vm_ports_attached_to_network
,
4623 mock_reload_connection
,
4624 mock_format_exception
,
4625 mock_extract_items_wth_keep_flag_from_created_items
,
4628 """extract_items_wth_keep_flag_from_created_items raises AttributeError."""
4629 vm_id
= f
"{virtual_mac_id}"
4630 initial_created_items
= {
4631 f
"port{port_id}": True,
4632 f
"floating_ip{floating_network_vim_id}": None,
4633 f
"volume{volume_id}keep": True,
4634 f
"volume{volume_id2}keep": True,
4637 mock_extract_items_wth_keep_flag_from_created_items
.side_effect
= AttributeError
4638 volumes_to_hold
= []
4639 mock_delete_created_items
.return_value
= False
4640 with self
.assertRaises(AttributeError):
4641 self
.vimconn
.delete_vminstance(
4642 vm_id
, initial_created_items
, volumes_to_hold
4644 mock_reload_connection
.assert_not_called()
4645 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4646 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4647 mock_delete_created_items
.assert_not_called()
4648 mock_sleep
.assert_not_called()
4649 mock_format_exception
.assert_not_called()
4650 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4651 initial_created_items
4654 @patch("time.sleep")
4655 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4656 @patch.object(vimconnector
, "_format_exception")
4657 @patch.object(vimconnector
, "_reload_connection")
4658 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4659 @patch.object(vimconnector
, "_delete_created_items")
4660 def test_delete_vminstance_delete_created_items_raises(
4662 mock_delete_created_items
,
4663 mock_delete_vm_ports_attached_to_network
,
4664 mock_reload_connection
,
4665 mock_format_exception
,
4666 mock_extract_items_wth_keep_flag_from_created_items
,
4669 """Delete creted items raises exception."""
4670 vm_id
= f
"{virtual_mac_id}"
4671 created_items
= deepcopy(created_items_all_true
)
4672 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4673 mock_sleep
= MagicMock()
4674 volumes_to_hold
= []
4675 err
= ConnectionError("ClientException occurred.")
4676 mock_delete_created_items
.side_effect
= err
4677 with self
.assertRaises(ConnectionError
) as err
:
4678 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4679 self
.assertEqual(str(err
), "ClientException occurred.")
4680 mock_reload_connection
.assert_called_once()
4681 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4682 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4683 mock_delete_created_items
.assert_called_once()
4684 mock_sleep
.assert_not_called()
4685 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4689 @patch("time.sleep")
4690 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4691 @patch.object(vimconnector
, "_format_exception")
4692 @patch.object(vimconnector
, "_reload_connection")
4693 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4694 @patch.object(vimconnector
, "_delete_created_items")
4695 def test_delete_vminstance_delete_vm_ports_raises(
4697 mock_delete_created_items
,
4698 mock_delete_vm_ports_attached_to_network
,
4699 mock_reload_connection
,
4700 mock_format_exception
,
4701 mock_extract_items_wth_keep_flag_from_created_items
,
4704 """Delete vm ports raises exception."""
4705 vm_id
= f
"{virtual_mac_id}"
4706 created_items
= deepcopy(created_items_all_true
)
4707 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4708 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4709 err
= ConnectionError("ClientException occurred.")
4710 mock_delete_vm_ports_attached_to_network
.side_effect
= err
4711 mock_delete_created_items
.side_effect
= err
4712 with self
.assertRaises(ConnectionError
) as err
:
4713 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4714 self
.assertEqual(str(err
), "ClientException occurred.")
4715 mock_reload_connection
.assert_called_once()
4716 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4717 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4718 mock_delete_created_items
.assert_not_called()
4719 mock_sleep
.assert_not_called()
4720 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4724 @patch("time.sleep")
4725 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4726 @patch.object(vimconnector
, "_format_exception")
4727 @patch.object(vimconnector
, "_reload_connection")
4728 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4729 @patch.object(vimconnector
, "_delete_created_items")
4730 def test_delete_vminstance_nova_server_delete_raises(
4732 mock_delete_created_items
,
4733 mock_delete_vm_ports_attached_to_network
,
4734 mock_reload_connection
,
4735 mock_format_exception
,
4736 mock_extract_items_wth_keep_flag_from_created_items
,
4739 """Nova server delete raises exception."""
4740 vm_id
= f
"{virtual_mac_id}"
4741 created_items
= deepcopy(created_items_all_true
)
4742 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4743 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4744 err
= VimConnConnectionException("ClientException occurred.")
4745 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
4746 mock_delete_created_items
.side_effect
= err
4747 with self
.assertRaises(VimConnConnectionException
) as err
:
4748 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4749 self
.assertEqual(str(err
), "ClientException occurred.")
4750 mock_reload_connection
.assert_called_once()
4751 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4752 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4753 mock_delete_created_items
.assert_not_called()
4754 mock_sleep
.assert_not_called()
4755 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4759 @patch("time.sleep")
4760 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4761 @patch.object(vimconnector
, "_format_exception")
4762 @patch.object(vimconnector
, "_reload_connection")
4763 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4764 @patch.object(vimconnector
, "_delete_created_items")
4765 def test_delete_vminstance_reload_connection_raises(
4767 mock_delete_created_items
,
4768 mock_delete_vm_ports_attached_to_network
,
4769 mock_reload_connection
,
4770 mock_format_exception
,
4771 mock_extract_items_wth_keep_flag_from_created_items
,
4774 """Reload connection raises exception."""
4775 vm_id
= f
"{virtual_mac_id}"
4776 created_items
= deepcopy(created_items_all_true
)
4777 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4778 mock_sleep
= MagicMock()
4779 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4780 err
= ConnectionError("ClientException occurred.")
4781 mock_delete_created_items
.return_value
= False
4782 mock_reload_connection
.side_effect
= err
4783 with self
.assertRaises(ConnectionError
) as err
:
4784 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4785 self
.assertEqual(str(err
), "ClientException occurred.")
4786 mock_reload_connection
.assert_called_once()
4787 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4788 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4789 mock_delete_created_items
.assert_not_called()
4790 mock_sleep
.assert_not_called()
4791 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4795 @patch("time.sleep")
4796 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4797 @patch.object(vimconnector
, "_format_exception")
4798 @patch.object(vimconnector
, "_reload_connection")
4799 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4800 @patch.object(vimconnector
, "_delete_created_items")
4801 def test_delete_vminstance_created_item_vol_to_hold_are_none(
4803 mock_delete_created_items
,
4804 mock_delete_vm_ports_attached_to_network
,
4805 mock_reload_connection
,
4806 mock_format_exception
,
4807 mock_extract_items_wth_keep_flag_from_created_items
,
4810 """created_items and volumes_to_hold are None."""
4811 vm_id
= f
"{virtual_mac_id}"
4812 created_items
= None
4813 volumes_to_hold
= None
4814 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= {}
4815 mock_delete_created_items
.return_value
= False
4816 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4817 mock_reload_connection
.assert_called_once()
4818 mock_delete_vm_ports_attached_to_network
.assert_not_called()
4819 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
4820 mock_delete_created_items
.assert_called_once_with({}, [], False)
4821 mock_sleep
.assert_not_called()
4822 mock_format_exception
.assert_not_called()
4823 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with({})
4825 @patch("time.sleep")
4826 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4827 @patch.object(vimconnector
, "_format_exception")
4828 @patch.object(vimconnector
, "_reload_connection")
4829 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4830 @patch.object(vimconnector
, "_delete_created_items")
4831 def test_delete_vminstance_vm_id_is_none(
4833 mock_delete_created_items
,
4834 mock_delete_vm_ports_attached_to_network
,
4835 mock_reload_connection
,
4836 mock_format_exception
,
4837 mock_extract_items_wth_keep_flag_from_created_items
,
4840 """vm_id is None."""
4842 created_items
= deepcopy(created_items_all_true
)
4843 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4844 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4845 mock_delete_created_items
.side_effect
= [True, True, False]
4846 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4847 mock_reload_connection
.assert_called_once()
4848 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4849 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4850 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
4851 self
.assertEqual(mock_sleep
.call_count
, 2)
4852 mock_format_exception
.assert_not_called()
4853 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4857 @patch("time.sleep")
4858 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
4859 @patch.object(vimconnector
, "_format_exception")
4860 @patch.object(vimconnector
, "_reload_connection")
4861 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
4862 @patch.object(vimconnector
, "_delete_created_items")
4863 def test_delete_vminstance_delete_created_items_return_true(
4865 mock_delete_created_items
,
4866 mock_delete_vm_ports_attached_to_network
,
4867 mock_reload_connection
,
4868 mock_format_exception
,
4869 mock_extract_items_wth_keep_flag_from_created_items
,
4872 """Delete created items always return True."""
4874 created_items
= deepcopy(created_items_all_true
)
4875 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
4876 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4877 mock_delete_created_items
.side_effect
= [True] * 1800
4878 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
4879 mock_reload_connection
.assert_called_once()
4880 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
4881 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
4882 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
4883 self
.assertEqual(mock_sleep
.call_count
, 1800)
4884 mock_format_exception
.assert_not_called()
4885 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
4889 def test_remove_keep_tag_from_persistent_volumes_keep_flag_exists(self
):
4890 """Keep flag exists in created items."""
4892 f
"port:{port_id}": True,
4893 f
"floating_ip:{floating_network_vim_id}": True,
4894 f
"volume:{volume_id}:keep": True,
4895 f
"volume:{volume_id2}:keep": True,
4898 f
"port:{port_id}": True,
4899 f
"floating_ip:{floating_network_vim_id}": True,
4900 f
"volume:{volume_id}": True,
4901 f
"volume:{volume_id2}": True,
4903 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4904 self
.assertDictEqual(result
, expected_result
)
4906 def test_remove_keep_tag_from_persistent_volumes_without_keep_flag(self
):
4907 """Keep flag does not exist in created items."""
4909 f
"port:{port_id}": True,
4910 f
"floating_ip:{floating_network_vim_id}": True,
4911 f
"volume:{volume_id}": True,
4912 f
"volume:{volume_id2}": True,
4914 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
4915 self
.assertDictEqual(result
, created_items
)
4917 def test_update_block_device_mapping_empty_volume(self
):
4919 block_device_mapping
= {}
4920 base_disk_index
= 100
4923 with self
.assertRaises(VimConnException
) as err
:
4924 self
.vimconn
.update_block_device_mapping(
4925 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4927 self
.assertEqual(str(err
), "Volume is empty.")
4928 self
.assertEqual(block_device_mapping
, {})
4929 self
.assertEqual(created_items
, {})
4931 def test_update_block_device_mapping_invalid_volume(self
):
4933 block_device_mapping
= {}
4934 base_disk_index
= 100
4937 with self
.assertRaises(VimConnException
) as err
:
4938 self
.vimconn
.update_block_device_mapping(
4939 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4942 str(err
), "Created volume is not valid, does not have id attribute."
4944 self
.assertEqual(block_device_mapping
, {})
4945 self
.assertEqual(created_items
, {})
4947 def test_update_block_device_mapping(self
):
4948 volume
= MagicMock(autospec
=True)
4949 volume
.id = volume_id
4950 block_device_mapping
= {}
4951 base_disk_index
= 100
4954 self
.vimconn
.update_block_device_mapping(
4955 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4958 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4961 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a": True}
4964 def test_update_block_device_mapping_with_keep_flag(self
):
4965 volume
= MagicMock(autospec
=True)
4966 volume
.id = volume_id
4967 block_device_mapping
= {}
4968 base_disk_index
= 100
4969 disk
= {"size": 10, "keep": True}
4971 self
.vimconn
.update_block_device_mapping(
4972 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
4975 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
4978 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a:keep": True}
4981 def test_extract_items_with_keep_flag_item_has_keep_flag(self
):
4982 created_items
= deepcopy(created_items_all_true
)
4983 created_items
[f
"volume:{volume_id2}:keep"] = True
4984 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4987 self
.assertEqual(result
, deepcopy(created_items_all_true
))
4989 def test_extract_items_with_keep_flag_no_item_wth_keep_flag(self
):
4990 created_items
= deepcopy(created_items_all_true
)
4991 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
4994 self
.assertEqual(result
, deepcopy(created_items_all_true
))
4996 def test_extract_items_with_keep_flag_all_items_are_already_deleted(self
):
4998 f
"port:{port_id}": None,
4999 f
"floating_ip:{floating_network_vim_id}": None,
5000 f
"volume:{volume_id}:keep": None,
5001 f
"volume:{volume_id2}:keep": None,
5004 f
"port:{port_id}": None,
5005 f
"floating_ip:{floating_network_vim_id}": None,
5007 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5010 self
.assertEqual(result
, expected_result
)
5012 def test_extract_items_with_keep_flag_without_semicolon(self
):
5014 f
"port{port_id}": True,
5015 f
"floating_ip{floating_network_vim_id}": None,
5016 f
"volume{volume_id}keep": True,
5017 f
"volume{volume_id2}keep": True,
5019 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5022 self
.assertEqual(result
, {})
5024 def test_extract_items_with_keep_flag_invalid_type_created_items(self
):
5025 created_items
= [{f
"port{port_id}": True}, {f
"volume{volume_id2}keep": True}]
5026 with self
.assertRaises(AttributeError):
5027 self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(created_items
)
5029 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5030 def test_get_monitoring_data(self
, mock_reload_conection
):
5032 {"original_name": "flavor1", "id": "367fc1eb-bd22-40f8-a519-ed2fb4e5976b"},
5033 {"original_name": "flavor2", "id": "5dcf9732-d17d-40b3-910d-37fc4c5aacc0"},
5037 "server1", "ACTIVE", flavors
[0], "312200db-42e3-4772-9518-d5db85468392"
5040 "server2", "ACTIVE", flavors
[1], "39a166cf-e4e6-479c-b88c-9ad558cf2cbf"
5043 ports
= {"ports": ["port1", "port2"]}
5044 self
.vimconn
.nova
.servers
.list.return_value
= servers
5045 self
.vimconn
.neutron
.list_ports
.return_value
= ports
5046 result
= self
.vimconn
.get_monitoring_data()
5047 self
.assertTupleEqual(result
, (servers
, ports
))
5048 mock_reload_conection
.assert_called_once()
5049 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5050 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5052 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5053 def test_get_monitoring_data_reload_connection_raises(self
, mock_reload_conection
):
5054 mock_reload_conection
.side_effect
= VimConnNotFoundException(
5055 "Connection object not found."
5057 with self
.assertRaises(VimConnException
) as err
:
5058 result
= self
.vimconn
.get_monitoring_data()
5059 self
.assertTupleEqual(result
, None)
5061 str(err
.exception
.args
[0]),
5062 "Exception in monitoring while getting VMs and ports status: Connection object not found.",
5064 mock_reload_conection
.assert_called_once()
5065 check_if_assert_not_called(
5066 [self
.vimconn
.nova
.servers
.list, self
.vimconn
.neutron
.list_ports
]
5069 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5070 def test_get_monitoring_data_server_list_raises(self
, mock_reload_conection
):
5071 self
.vimconn
.nova
.servers
.list.side_effect
= VimConnConnectionException(
5072 "Can not connect to Cloud API."
5074 with self
.assertRaises(VimConnException
) as err
:
5075 result
= self
.vimconn
.get_monitoring_data()
5076 self
.assertTupleEqual(result
, None)
5078 str(err
.exception
.args
[0]),
5079 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5081 mock_reload_conection
.assert_called_once()
5082 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5083 self
.vimconn
.neutron
.list_ports
.assert_not_called()
5085 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5086 def test_get_monitoring_data_list_ports_raises(self
, mock_reload_conection
):
5087 self
.vimconn
.neutron
.list_ports
.side_effect
= VimConnConnectionException(
5088 "Can not connect to Cloud API."
5090 with self
.assertRaises(VimConnException
) as err
:
5091 result
= self
.vimconn
.get_monitoring_data()
5092 self
.assertTupleEqual(result
, None)
5094 str(err
.exception
.args
[0]),
5095 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5097 mock_reload_conection
.assert_called_once()
5098 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5099 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5102 class TestNewFlavor(unittest
.TestCase
):
5103 @patch("logging.getLogger", autospec
=True)
5104 def setUp(self
, mock_logger
):
5105 # We are disabling the logging of exception not to print them to console.
5106 mock_logger
= logging
.getLogger()
5107 mock_logger
.disabled
= True
5108 self
.vimconn
= vimconnector(
5118 self
.vimconn
.nova
= CopyingMock(autospec
=True)
5119 self
.flavor1
= CopyingMock(autospec
=True, name
="sample-flavor")
5120 self
.flavor2
= CopyingMock(autospec
=True, name
="other-flavor")
5121 self
.new_flavor
= CopyingMock(autospec
=True, name
="new_flavor")
5122 self
.new_flavor
.id = "075d2482-5edb-43e3-91b3-234e65b6268a"
5123 self
.vimconn
.nova
.flavors
.create
.return_value
= self
.new_flavor
5125 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5126 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5127 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5130 "process_numa_paired_threads",
5131 new_callable
=CopyingMock(),
5133 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5134 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5135 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_vio(
5137 mock_process_numa_threads
,
5138 mock_process_numa_cores
,
5139 mock_process_numa_paired_threads
,
5140 mock_process_numa_vcpu
,
5141 mock_process_numa_memory
,
5142 mock_process_vio_numa_nodes
,
5144 """Process numa parameters, id, memory, vcpu exist, vim type is VIO,
5145 paired-threads, cores, threads do not exist in numa.
5148 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5149 {"id": 1, "memory": 2, "vcpu": [2]},
5152 expected_extra_specs
= {
5153 "hw:numa_nodes": "2",
5154 "hw:cpu_sockets": "2",
5156 self
.vimconn
.vim_type
= "VIO"
5157 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5159 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5160 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5161 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5162 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5164 _call_mock_process_numa_memory
[0].args
,
5166 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5169 "hw:numa_nodes": "2",
5174 _call_mock_process_numa_memory
[1].args
,
5176 {"id": 1, "memory": 2, "vcpu": [2]},
5179 "hw:cpu_sockets": "2",
5180 "hw:numa_nodes": "2",
5184 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5186 _call_mock_process_numa_vcpu
[0].args
,
5188 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5191 "hw:numa_nodes": "2",
5196 _call_mock_process_numa_vcpu
[1].args
,
5198 {"id": 1, "memory": 2, "vcpu": [2]},
5201 "hw:cpu_sockets": "2",
5202 "hw:numa_nodes": "2",
5206 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5207 check_if_assert_not_called(
5209 mock_process_numa_threads
,
5210 mock_process_numa_cores
,
5211 mock_process_numa_paired_threads
,
5215 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5216 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5217 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5220 "process_numa_paired_threads",
5221 new_callable
=CopyingMock(),
5223 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5224 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5225 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_openstack(
5227 mock_process_numa_threads
,
5228 mock_process_numa_cores
,
5229 mock_process_numa_paired_threads
,
5230 mock_process_numa_vcpu
,
5231 mock_process_numa_memory
,
5232 mock_process_vio_numa_nodes
,
5234 """Process numa parameters, id, memory, vcpu exist, vim type is openstack,
5235 paired-threads, cores, threads do not exist in numa.
5238 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5239 {"id": 1, "memory": 2, "vcpu": [2]},
5242 expected_extra_specs
= {
5243 "hw:numa_nodes": "2",
5244 "hw:cpu_sockets": "2",
5246 self
.vimconn
.vim_type
= "openstack"
5247 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5249 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5250 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5251 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5253 _call_mock_process_numa_memory
[0].args
,
5255 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5257 {"hw:numa_nodes": "2"},
5261 _call_mock_process_numa_memory
[1].args
,
5263 {"id": 1, "memory": 2, "vcpu": [2]},
5265 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5268 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5270 _call_mock_process_numa_vcpu
[0].args
,
5272 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5274 {"hw:numa_nodes": "2"},
5278 _call_mock_process_numa_vcpu
[1].args
,
5280 {"id": 1, "memory": 2, "vcpu": [2]},
5282 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5285 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5286 check_if_assert_not_called(
5288 mock_process_numa_threads
,
5289 mock_process_numa_cores
,
5290 mock_process_numa_paired_threads
,
5294 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5295 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5296 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5299 "process_numa_paired_threads",
5300 new_callable
=CopyingMock(),
5302 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5303 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5304 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_openstack_extra_spec_not_empty(
5306 mock_process_numa_threads
,
5307 mock_process_numa_cores
,
5308 mock_process_numa_paired_threads
,
5309 mock_process_numa_vcpu
,
5310 mock_process_numa_memory
,
5311 mock_process_vio_numa_nodes
,
5313 """Process numa parameters, id, paired-threads exist, vim type is openstack.
5314 vcpus calculation according to paired-threads in numa, there is extra_spec.
5316 numas
= [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
5317 extra_specs
= {"some-key": "some-value"}
5318 expected_extra_specs
= {
5319 "hw:cpu_sockets": "2",
5320 "hw:cpu_threads": "12",
5321 "hw:numa_nodes": "2",
5322 "some-key": "some-value",
5324 self
.vimconn
.vim_type
= "openstack"
5325 mock_process_numa_paired_threads
.side_effect
= [6, 6]
5326 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5328 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5329 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5330 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5331 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5332 _call_mock_process_numa_paired_threads
= (
5333 mock_process_numa_paired_threads
.call_args_list
5336 _call_mock_process_numa_paired_threads
[0].args
,
5338 {"id": 0, "paired-threads": 3},
5339 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5343 _call_mock_process_numa_paired_threads
[1].args
,
5345 {"id": 1, "paired-threads": 3},
5346 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5349 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5351 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5352 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5353 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5356 "process_numa_paired_threads",
5357 new_callable
=CopyingMock(),
5359 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5360 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5361 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_vio_extra_spec_not_empty(
5363 mock_process_numa_threads
,
5364 mock_process_numa_cores
,
5365 mock_process_numa_paired_threads
,
5366 mock_process_numa_vcpu
,
5367 mock_process_numa_memory
,
5368 mock_process_vio_numa_nodes
,
5370 """Process numa parameters, id, paired-threads exist, vim type is VIO.
5371 vcpus calculation according to paired-threads in numa, there is extra_spec.
5373 numas
= [{"id": 0, "paired-threads": 2}, {"id": 1, "paired-threads": 2}]
5374 extra_specs
= {"some-key": "some-value"}
5375 expected_extra_specs
= {
5376 "hw:numa_nodes": "2",
5377 "hw:cpu_sockets": "2",
5378 "hw:cpu_threads": "8",
5379 "some-key": "some-value",
5381 self
.vimconn
.vim_type
= "VIO"
5382 mock_process_numa_paired_threads
.side_effect
= [4, 4]
5383 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5384 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5385 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5386 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5387 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5388 _call_mock_process_numa_paired_threads
= (
5389 mock_process_numa_paired_threads
.call_args_list
5391 mock_process_vio_numa_nodes
.assert_called_once_with(
5392 2, {"some-key": "some-value", "hw:numa_nodes": "2"}
5395 _call_mock_process_numa_paired_threads
[0].args
,
5397 {"id": 0, "paired-threads": 2},
5399 "hw:cpu_sockets": "2",
5400 "hw:numa_nodes": "2",
5401 "some-key": "some-value",
5406 _call_mock_process_numa_paired_threads
[1].args
,
5408 {"id": 1, "paired-threads": 2},
5410 "hw:cpu_sockets": "2",
5411 "hw:numa_nodes": "2",
5412 "some-key": "some-value",
5416 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5418 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5419 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5420 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5423 "process_numa_paired_threads",
5424 new_callable
=CopyingMock(),
5426 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5427 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5428 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_openstack(
5430 mock_process_numa_threads
,
5431 mock_process_numa_cores
,
5432 mock_process_numa_paired_threads
,
5433 mock_process_numa_vcpu
,
5434 mock_process_numa_memory
,
5435 mock_process_vio_numa_nodes
,
5437 """Process numa parameters, id, cores exist, vim type is openstack.
5438 vcpus calculation according to cores in numa.
5440 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5442 updated_extra_specs
= {"hw:numa_nodes": "2", "hw:cpu_sockets": "2"}
5443 expected_extra_specs
= {
5444 "hw:numa_nodes": "2",
5445 "hw:cpu_sockets": "2",
5446 "hw:cpu_cores": "3",
5448 self
.vimconn
.vim_type
= "openstack"
5449 mock_process_numa_cores
.side_effect
= [1, 2]
5450 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5452 check_if_assert_not_called(
5453 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5455 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5456 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5457 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5458 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5460 _call_mock_process_numa_cores
[0].args
,
5461 ({"id": 0, "cores": 1}, updated_extra_specs
),
5464 _call_mock_process_numa_cores
[1].args
,
5465 ({"id": 1, "cores": 2}, updated_extra_specs
),
5467 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5469 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5470 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5471 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5474 "process_numa_paired_threads",
5475 new_callable
=CopyingMock(),
5477 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5478 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5479 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_vio(
5481 mock_process_numa_threads
,
5482 mock_process_numa_cores
,
5483 mock_process_numa_paired_threads
,
5484 mock_process_numa_vcpu
,
5485 mock_process_numa_memory
,
5486 mock_process_vio_numa_nodes
,
5488 """Process numa parameters, id, cores exist, vim type is VIO.
5489 vcpus calculation according to cores in numa.
5491 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5493 expected_extra_specs
= {
5494 "hw:cpu_cores": "3",
5495 "hw:cpu_sockets": "2",
5496 "hw:numa_nodes": "2",
5498 self
.vimconn
.vim_type
= "VIO"
5499 mock_process_numa_cores
.side_effect
= [1, 2]
5500 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5501 check_if_assert_not_called(
5502 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5504 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5505 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5506 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5507 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5508 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5510 _call_mock_process_numa_cores
[0].args
,
5512 {"id": 0, "cores": 1},
5514 "hw:cpu_sockets": "2",
5515 "hw:numa_nodes": "2",
5520 _call_mock_process_numa_cores
[1].args
,
5522 {"id": 1, "cores": 2},
5524 "hw:cpu_sockets": "2",
5525 "hw:numa_nodes": "2",
5529 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5531 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5532 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5533 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5536 "process_numa_paired_threads",
5537 new_callable
=CopyingMock(),
5539 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5540 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5541 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_vio(
5543 mock_process_numa_threads
,
5544 mock_process_numa_cores
,
5545 mock_process_numa_paired_threads
,
5546 mock_process_numa_vcpu
,
5547 mock_process_numa_memory
,
5548 mock_process_vio_numa_nodes
,
5550 """Process numa parameters, memory, vcpu, thread exist, vim type is VIO,
5551 vcpus calculation according threads in numa, there are not numa ids.
5554 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5555 {"memory": 2, "vcpu": [2]},
5558 expected_extra_specs
= {
5559 "hw:numa_nodes": "2",
5560 "hw:cpu_sockets": "2",
5561 "hw:cpu_threads": "3",
5563 self
.vimconn
.vim_type
= "VIO"
5564 mock_process_numa_threads
.return_value
= 3
5565 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5566 check_if_assert_not_called(
5568 mock_process_numa_memory
,
5569 mock_process_numa_vcpu
,
5570 mock_process_numa_cores
,
5571 mock_process_numa_paired_threads
,
5574 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5575 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5576 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5578 _call_mock_process_numa_threads
[0].args
,
5580 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5582 "hw:cpu_sockets": "2",
5583 "hw:numa_nodes": "2",
5587 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5589 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5590 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5591 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5594 "process_numa_paired_threads",
5595 new_callable
=CopyingMock(autospec
=True),
5597 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5598 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5599 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_openstack(
5601 mock_process_numa_threads
,
5602 mock_process_numa_cores
,
5603 mock_process_numa_paired_threads
,
5604 mock_process_numa_vcpu
,
5605 mock_process_numa_memory
,
5606 mock_process_vio_numa_nodes
,
5608 """Process numa parameters, memory, vcpu, thread exist, vim type is openstack,
5609 vcpus calculation according threads in numa, there are not numa ids.
5612 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5613 {"memory": 2, "vcpu": [2]},
5616 expected_extra_specs
= {
5617 "hw:numa_nodes": "2",
5618 "hw:cpu_sockets": "2",
5619 "hw:cpu_threads": "3",
5621 self
.vimconn
.vim_type
= "openstack"
5622 mock_process_numa_threads
.return_value
= 3
5623 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5625 check_if_assert_not_called(
5627 mock_process_numa_memory
,
5628 mock_process_numa_vcpu
,
5629 mock_process_numa_cores
,
5630 mock_process_numa_paired_threads
,
5631 mock_process_vio_numa_nodes
,
5634 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5635 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5637 _call_mock_process_numa_threads
[0].args
,
5639 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5640 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5643 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5645 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5646 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5647 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5650 "process_numa_paired_threads",
5651 new_callable
=CopyingMock(),
5653 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5654 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5655 def test_process_numa_parameters_of_flavor_empty_numas_list_type_vio(
5657 mock_process_numa_threads
,
5658 mock_process_numa_cores
,
5659 mock_process_numa_paired_threads
,
5660 mock_process_numa_vcpu
,
5661 mock_process_numa_memory
,
5662 mock_process_vio_numa_nodes
,
5664 """Numa list is empty, vim type is VIO."""
5667 expected_extra_specs
= {"hw:numa_nodes": "0"}
5668 self
.vimconn
.vim_type
= "VIO"
5669 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5670 check_if_assert_not_called(
5672 mock_process_numa_memory
,
5673 mock_process_numa_vcpu
,
5674 mock_process_numa_cores
,
5675 mock_process_numa_paired_threads
,
5676 mock_process_numa_threads
,
5679 mock_process_vio_numa_nodes
.assert_called_once_with(0, {"hw:numa_nodes": "0"})
5680 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5682 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5683 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5684 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5687 "process_numa_paired_threads",
5688 new_callable
=CopyingMock(),
5690 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5691 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5692 def test_process_numa_parameters_of_flavor_empty_numas_list_type_openstack(
5694 mock_process_numa_threads
,
5695 mock_process_numa_cores
,
5696 mock_process_numa_paired_threads
,
5697 mock_process_numa_vcpu
,
5698 mock_process_numa_memory
,
5699 mock_process_vio_numa_nodes
,
5701 """Numa list is empty, vim type is openstack."""
5704 expected_extra_specs
= {"hw:numa_nodes": "0"}
5705 self
.vimconn
.vim_type
= "openstack"
5706 mock_process_numa_threads
.return_value
= None
5707 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5709 check_if_assert_not_called(
5711 mock_process_numa_memory
,
5712 mock_process_numa_vcpu
,
5713 mock_process_numa_cores
,
5714 mock_process_numa_paired_threads
,
5715 mock_process_numa_threads
,
5716 mock_process_vio_numa_nodes
,
5719 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5721 def test_process_numa_memory_empty_extra_spec(self
):
5722 numa
= {"memory": 2, "vcpu": [2]}
5725 expected_extra_spec
= {"hw:numa_mem.2": 2048}
5726 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5727 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5729 def test_process_numa_memory_not_exist(self
):
5730 numa
= {"vcpu": [2]}
5732 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5733 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5734 self
.assertDictEqual(extra_specs
, {"vmware:latency_sensitivity_level": "high"})
5736 def test_process_numa_memory_node_id_is_none(self
):
5737 numa
= {"memory": 2, "vcpu": [2]}
5740 expected_extra_spec
= {"hw:numa_mem.None": 2048}
5741 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
5742 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5744 def test_process_numa_vcpu_empty_extra_spec(self
):
5745 numa
= {"vcpu": [2]}
5748 expected_extra_spec
= {"hw:numa_cpus.0": "2"}
5749 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5750 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5752 def test_process_numa_vcpu_not_exist(self
):
5753 numa
= {"memory": 2}
5755 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
5756 expected_extra_spec
= {"vmware:latency_sensitivity_level": "high"}
5757 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5758 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5760 def test_process_numa_vcpu_empty_node_id(self
):
5761 numa
= {"vcpu": [2]}
5764 expected_extra_spec
= {"hw:numa_cpus.": "2"}
5765 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5766 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5768 def test_process_numa_vcpu_empty_numa_dict(self
):
5772 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5773 self
.assertDictEqual(extra_specs
, {})
5775 def test_process_numa_vcpu_str_node_id(self
):
5776 numa
= {"vcpu": [2]}
5779 expected_extra_spec
= {"hw:numa_cpus.12": "2"}
5780 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
5781 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5783 def test_process_numa_paired_threads_empty_extra_spec(self
):
5784 numa
= {"id": 0, "paired-threads": 3}
5786 expected_extra_spec
= {
5787 "hw:cpu_thread_policy": "require",
5788 "hw:cpu_policy": "dedicated",
5790 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5791 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5792 self
.assertEqual(result
, 6)
5794 def test_process_numa_paired_threads_empty_numa(self
):
5797 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5798 self
.assertDictEqual(extra_specs
, {})
5799 self
.assertEqual(result
, None)
5801 def test_process_numa_paired_threads_not_exist(self
):
5802 numa
= {"vcpu": [2]}
5804 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5805 self
.assertDictEqual(extra_specs
, {})
5806 self
.assertEqual(result
, None)
5808 def test_process_numa_paired_threads_str_thread_num(self
):
5809 numa
= {"id": 0, "paired-threads": "3"}
5811 expected_extra_spec
= {
5812 "hw:cpu_thread_policy": "require",
5813 "hw:cpu_policy": "dedicated",
5815 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5816 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5817 self
.assertEqual(result
, "33")
5819 def test_process_numa_paired_threads_none_thread_num(self
):
5820 numa
= {"id": 0, "paired-threads": None}
5822 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
5823 self
.assertDictEqual(extra_specs
, {})
5824 self
.assertEqual(result
, None)
5826 def test_process_numa_cores_empty_extra_spec(self
):
5827 numa
= {"id": 0, "cores": 1}
5829 expected_extra_spec
= {
5830 "hw:cpu_policy": "dedicated",
5831 "hw:cpu_thread_policy": "isolate",
5833 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5834 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5835 self
.assertEqual(result
, 1)
5837 def test_process_numa_cores_not_exist(self
):
5838 numa
= {"id": 0, "paired-threads": 3}
5840 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5841 self
.assertDictEqual(extra_specs
, {})
5842 self
.assertEqual(result
, None)
5844 def test_process_numa_cores_empty_numa(self
):
5846 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5847 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5848 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5849 self
.assertEqual(result
, None)
5851 def test_process_numa_cores_none_core_num(self
):
5852 numa
= {"memory": 1, "cores": None}
5854 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5855 self
.assertDictEqual(extra_specs
, {})
5856 self
.assertEqual(result
, None)
5858 def test_process_numa_cores_string_core_num(self
):
5859 numa
= {"id": 0, "cores": "1"}
5860 extra_specs
= {"some-key": "some-val"}
5861 expected_extra_spec
= {
5862 "hw:cpu_policy": "dedicated",
5863 "hw:cpu_thread_policy": "isolate",
5864 "some-key": "some-val",
5866 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5867 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5868 self
.assertEqual(result
, "1")
5870 def test_process_numa_cores_float_core_num(self
):
5871 numa
= {"memory": 2, "cores": 10.03}
5872 extra_specs
= {"some-key": "some-val"}
5873 expected_extra_spec
= {
5874 "hw:cpu_policy": "dedicated",
5875 "hw:cpu_thread_policy": "isolate",
5876 "some-key": "some-val",
5878 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
5879 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5880 self
.assertEqual(result
, 10.03)
5882 def test_process_numa_threads_empty_extra_spec_int_thread_num(self
):
5883 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3}
5885 expected_extra_spec
= {
5886 "hw:cpu_policy": "dedicated",
5887 "hw:cpu_thread_policy": "prefer",
5889 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5890 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5891 self
.assertEqual(result
, 3)
5893 def test_process_numa_threads_empty_numa(self
):
5895 extra_specs
= {"some-key": "some-val"}
5896 expected_extra_spec
= {"some-key": "some-val"}
5897 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5898 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5899 self
.assertEqual(result
, None)
5901 def test_process_numa_threads_not_exist(self
):
5902 numa
= {"memory": 1}
5903 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
5904 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5905 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5906 self
.assertEqual(result
, None)
5908 def test_process_numa_threads_str_thread_num(self
):
5909 numa
= {"vcpu": [1, 3], "threads": "3"}
5911 expected_extra_spec
= {
5912 "hw:cpu_policy": "dedicated",
5913 "hw:cpu_thread_policy": "prefer",
5915 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5916 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5917 self
.assertEqual(result
, "3")
5919 def test_process_numa_threads_none_thread_num(self
):
5920 numa
= {"vcpu": [1, 3], "threads": None}
5922 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5923 self
.assertDictEqual(extra_specs
, {})
5924 self
.assertEqual(result
, None)
5926 def test_process_numa_threads_float_thread_num(self
):
5927 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3.3}
5928 extra_specs
= {"some-key": "some-val"}
5929 expected_extra_spec
= {
5930 "hw:cpu_policy": "dedicated",
5931 "hw:cpu_thread_policy": "prefer",
5932 "some-key": "some-val",
5934 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
5935 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
5936 self
.assertEqual(result
, 3.3)
5938 def test_change_the_flavor_name_not_existing_name(self
):
5939 """Flavor name does not exist in Openstack flavor list."""
5940 self
.flavor1
.name
= "sample-flavor-3"
5941 self
.flavor2
.name
= "other-flavor-4"
5942 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5943 name
= "other-flavor-3"
5945 flavor_data
= {"name": "other-flavor"}
5946 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5947 self
.assertEqual(result
, name
)
5948 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5949 # Checking whether name_suffix changed or not.
5950 self
.assertEqual(name_suffix
, 3)
5952 def test_change_the_flavor_name_existing_name(self
):
5953 """Flavor name exists in Openstack flavor list."""
5954 self
.flavor1
.name
= "other-flavor-6"
5955 self
.flavor2
.name
= "other-flavor-3"
5956 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5957 name
= "other-flavor-3"
5959 flavor_data
= {"name": "other-flavor"}
5960 expected_result
= "other-flavor-7"
5961 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5962 self
.assertEqual(result
, expected_result
)
5963 # Checking whether name_suffix changed or not.
5964 self
.assertEqual(name_suffix
, 5)
5965 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5967 def test_change_the_flavor_name_flavor_data_does_not_have_name(self
):
5968 """Flavor data does not have name."""
5969 self
.flavor1
.name
= "other-flavor-6"
5970 self
.flavor2
.name
= "other-flavor-3"
5971 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5972 name
= "other-flavor-3"
5975 with self
.assertRaises(KeyError):
5976 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5977 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5978 # Checking whether name_suffix changed or not.
5979 self
.assertEqual(name_suffix
, 5)
5981 def test_change_the_flavor_name_invalid_name_suffix(self
):
5982 """Name suffix is invalid."""
5983 self
.flavor1
.name
= "other-flavor-6"
5984 self
.flavor2
.name
= "other-flavor-3"
5985 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
5986 name
= "other-flavor-3"
5988 flavor_data
= {"name": "other-flavor"}
5989 with self
.assertRaises(TypeError):
5990 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
5991 self
.vimconn
.nova
.flavors
.list.assert_called_once()
5992 # Checking whether name_suffix changed or not.
5993 self
.assertEqual(name_suffix
, "a")
5995 def test_change_the_flavor_name_given_name_is_empty(self
):
5996 """Given name is empty string."""
5997 self
.flavor1
.name
= "other-flavor-6"
5998 self
.flavor2
.name
= "other-flavor-3"
5999 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6002 flavor_data
= {"name": "other-flavor"}
6003 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6004 self
.assertEqual(result
, "")
6005 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6006 # Checking whether name_suffix increased or not.
6007 self
.assertEqual(name_suffix
, 3)
6009 def test_change_the_flavor_name_given_name_is_none(self
):
6010 """Given name is None."""
6011 self
.flavor1
.name
= "other-flavor-6"
6012 self
.flavor2
.name
= "other-flavor-3"
6013 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6016 flavor_data
= {"name": "other-flavor"}
6017 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6018 self
.assertEqual(result
, None)
6019 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6020 # Checking whether name_suffix increased or not.
6021 self
.assertEqual(name_suffix
, 6)
6023 def test_change_the_flavor_name_empty_nova_flavor_list(self
):
6024 """Nova flavor list is empty."""
6025 self
.vimconn
.nova
.flavors
.list.return_value
= []
6026 name
= "other-flavor-3"
6028 flavor_data
= {"name": "other-flavor"}
6029 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6030 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6031 self
.assertEqual(result
, name
)
6032 # Checking whether name_suffix increased or not.
6033 self
.assertEqual(name_suffix
, 5)
6037 "_process_numa_parameters_of_flavor",
6038 new_callable
=CopyingMock(),
6040 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6041 def test_process_extended_config_of_flavor_with_numa_cpu_mem_vif_disk_quota(
6042 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6044 """Process extended config, extended has numas, cpu, mem, vif and disk-io quota."""
6046 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6047 {"memory": 2, "vcpu": [2]},
6051 "cpu-quota": {"limit": 3},
6052 "mem-quota": {"limit": 1},
6053 "vif-quota": {"limit": 10},
6054 "disk-io-quota": {"limit": 50},
6055 "mempage-size": "LARGE",
6058 expected_extra_specs
= {
6059 "hw:mem_page_size": "large",
6061 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6063 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6064 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6065 self
.assertEqual(extra_specs
, expected_extra_specs
)
6069 "_process_numa_parameters_of_flavor",
6070 new_callable
=CopyingMock(),
6072 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6073 def test_process_extended_config_of_flavor_with_numa_wrong_disk_quota(
6074 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6076 """Process extended config, extended has wrong disk quota key."""
6078 {"memory": 1, "threads": 3},
6079 {"memory": 2, "vcpu": [2]},
6083 "disk-quota": {"limit": 50},
6084 "mempage-size": "PREFER_LARGE",
6087 expected_extra_specs
= {
6088 "hw:mem_page_size": "any",
6090 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6091 mock_process_resource_quota
.assert_not_called()
6092 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6093 self
.assertEqual(extra_specs
, expected_extra_specs
)
6097 "_process_numa_parameters_of_flavor",
6098 new_callable
=CopyingMock(),
6100 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6101 def test_process_extended_config_of_flavor_without_numa_cpu_mem_vif_disk_quota(
6102 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6104 """Process extended config, extended has cpu, mem, vif and disk-io quota but not numas."""
6106 "cpu-quota": {"limit": 3},
6107 "mem-quota": {"limit": 1},
6108 "vif-quota": {"limit": 10},
6109 "disk-io-quota": {"limit": 50},
6110 "mempage-size": "SMALL",
6113 expected_extra_specs
= {
6114 "hw:mem_page_size": "small",
6116 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6117 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6118 mock_process_numa_parameters_of_flavor
.assert_not_called()
6119 self
.assertEqual(extra_specs
, expected_extra_specs
)
6123 "_process_numa_parameters_of_flavor",
6124 new_callable
=CopyingMock(),
6126 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6127 def test_process_extended_config_of_flavor_with_numa_with_cpu_pinning_mem_policy(
6128 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6130 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy."""
6133 {"memory": 2, "vcpu": [2]},
6137 "cpu-quota": {"limit": 3},
6138 "mem-quota": {"limit": 1},
6139 "mempage-size": "LARGE",
6140 "cpu-pinning-policy": "DEDICATED",
6141 "mem-policy": "STRICT",
6144 expected_extra_specs
= {
6145 "hw:mem_page_size": "large",
6146 "hw:cpu_policy": "dedicated",
6147 "hw:numa_mempolicy": "strict",
6149 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6150 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6151 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6152 self
.assertEqual(extra_specs
, expected_extra_specs
)
6156 "_process_numa_parameters_of_flavor",
6157 new_callable
=CopyingMock(),
6159 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6160 def test_process_extended_config_of_flavor_without_numa_with_cpu_pinning_mem_policy(
6161 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6163 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy but not numas."""
6165 "cpu-quota": {"limit": 3},
6166 "mem-quota": {"limit": 1},
6167 "mempage-size": "LARGE",
6168 "cpu-pinning-policy": "DEDICATED",
6169 "mem-policy": "STRICT",
6172 expected_extra_specs
= {
6173 "hw:mem_page_size": "large",
6174 "hw:cpu_policy": "dedicated",
6175 "hw:numa_mempolicy": "strict",
6177 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6178 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6179 mock_process_numa_parameters_of_flavor
.assert_not_called()
6180 self
.assertEqual(extra_specs
, expected_extra_specs
)
6184 "_process_numa_parameters_of_flavor",
6185 new_callable
=CopyingMock(),
6187 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6188 def test_process_extended_config_of_flavor_without_numa_with_wrong_mempage_size(
6189 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6191 """Process extended config, extended has wrong mempage-size without numas."""
6193 "cpu-quota": {"limit": 3},
6194 "mem-quota": {"limit": 1},
6195 "mempage-size": "SIZE_2GB",
6196 "cpu-pinning-policy": "DEDICATED",
6197 "mem-policy": "STRICT",
6201 expected_extra_specs
= {
6202 "hw:cpu_policy": "dedicated",
6203 "hw:numa_mempolicy": "strict",
6205 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6206 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6207 mock_process_numa_parameters_of_flavor
.assert_not_called()
6208 self
.assertEqual(extra_specs
, expected_extra_specs
)
6212 "_process_numa_parameters_of_flavor",
6213 new_callable
=CopyingMock(),
6215 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6216 def test_process_extended_config_of_flavor_with_numa_with_wrong_mempage_size(
6217 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6219 """Process extended config, extended has wrong mempage-size with numas."""
6222 {"memory": 2, "vcpu": [2]},
6226 "cpu-quota": {"limit": 3},
6227 "mem-quota": {"limit": 1},
6228 "mempage-size": "SIZE_2GB",
6229 "cpu-pinning-policy": "DEDICATED",
6230 "mem-policy": "STRICT",
6233 expected_extra_specs
= {
6234 "hw:cpu_policy": "dedicated",
6235 "hw:numa_mempolicy": "strict",
6237 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6238 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6239 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6240 self
.assertEqual(extra_specs
, expected_extra_specs
)
6244 "_process_numa_parameters_of_flavor",
6245 new_callable
=CopyingMock(),
6247 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6248 def test_process_extended_config_of_flavor_none_vcpus(
6249 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6251 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6254 {"memory": 2, "vcpu": [2]},
6258 "cpu-quota": {"limit": 3},
6259 "mem-quota": {"limit": 1},
6260 "mempage-size": "SIZE_2GB",
6261 "cpu-pinning-policy": "DEDICATED",
6262 "mem-policy": "STRICT",
6265 expected_extra_specs
= {
6266 "hw:cpu_policy": "dedicated",
6267 "hw:numa_mempolicy": "strict",
6269 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6270 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6271 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6272 self
.assertEqual(extra_specs
, expected_extra_specs
)
6276 "_process_numa_parameters_of_flavor",
6277 new_callable
=CopyingMock(),
6279 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6280 def test_process_extended_config_of_flavor_none_vcpus_without_numas(
6281 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6283 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6285 "cpu-quota": {"limit": 3},
6286 "mem-quota": {"limit": 1},
6287 "mempage-size": "SIZE_2GB",
6288 "cpu-pinning-policy": "DEDICATED",
6289 "mem-policy": "STRICT",
6291 extra_specs
= {"some-key": "some-val"}
6292 expected_extra_specs
= {
6293 "hw:cpu_policy": "dedicated",
6294 "hw:numa_mempolicy": "strict",
6295 "some-key": "some-val",
6297 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6298 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6299 mock_process_numa_parameters_of_flavor
.assert_not_called()
6300 self
.assertEqual(extra_specs
, expected_extra_specs
)
6304 "_process_numa_parameters_of_flavor",
6305 new_callable
=CopyingMock(),
6307 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6308 def test_process_extended_config_of_flavor_wrong_cpu_pinning_mem_policy_empty_vcpus(
6309 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6311 """Process extended config, extended has wrong cpu-pinning and mem-policy keys."""
6314 {"memory": 2, "vcpu": [2]},
6318 "cpu-quota": {"limit": 3},
6319 "mem-quota": {"limit": 1},
6320 "mempage-size": "SIZE_2GB",
6321 "cpu-pinning-pol": "DEDICATED",
6322 "mem-pol": "STRICT",
6325 expected_extra_specs
= {}
6326 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6327 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6328 mock_process_numa_parameters_of_flavor
.assert_called_once_with(
6331 self
.assertEqual(extra_specs
, expected_extra_specs
)
6335 "_process_numa_parameters_of_flavor",
6336 new_callable
=CopyingMock(),
6338 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6339 def test_process_extended_config_of_flavor_empty_extended(
6340 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6342 """Process extended config, extended is empty."""
6345 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6346 check_if_assert_not_called(
6347 [mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
]
6349 self
.assertEqual(extra_specs
, {})
6351 def test_get_flavor_details_empty_flavor_data(self
):
6353 expected_result
= (64, 1, {}, None)
6354 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6355 self
.assertEqual(result
, expected_result
)
6357 def test_get_flavor_details_flavor_data_has_ram_vcpus_extended(self
):
6362 "some-key": "some-val",
6365 expected_result
= (32, 3, {}, {"some-key": "some-val"})
6366 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6367 self
.assertEqual(result
, expected_result
)
6369 def test_get_flavor_details_flavor_data_is_none(self
):
6371 with self
.assertRaises(AttributeError):
6372 self
.vimconn
._get
_flavor
_details
(flavor_data
)
6374 def test_get_flavor_details_flavor_data_has_only_extended(self
):
6377 "some-key": "some-val",
6380 expected_result
= (64, 1, {}, {"some-key": "some-val"})
6381 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6382 self
.assertEqual(result
, expected_result
)
6384 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6387 "_process_extended_config_of_flavor",
6388 new_callable
=CopyingMock(),
6390 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6391 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6392 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6393 def test_new_flavor_with_extended_with_extra_specs(
6395 mock_format_exception
,
6396 mock_reload_connection
,
6397 mock_change_flavor_name
,
6398 mock_extended_config_of_flavor
,
6399 mock_get_flavor_details
,
6401 """Create new flavor with using extended parameters and extra specs."""
6404 mock_change_flavor_name
.return_value
= name1
6405 mock_get_flavor_details
.return_value
= (
6408 {"some-key": "some-value"},
6411 expected_result
= self
.new_flavor
.id
6412 result
= self
.vimconn
.new_flavor(flavor_data
)
6413 self
.assertEqual(result
, expected_result
)
6414 mock_reload_connection
.assert_called_once()
6415 self
.new_flavor
.set_keys
.assert_called_once()
6416 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6417 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6418 mock_extended_config_of_flavor
.assert_called_once_with(
6419 extended
, {"some-key": "some-value"}
6421 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6422 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6424 mock_format_exception
.assert_not_called()
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_with_extended_without_extra_specs(
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 with using extended parameters without extra specs."""
6446 mock_change_flavor_name
.return_value
= name1
6447 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6448 expected_result
= self
.new_flavor
.id
6449 result
= self
.vimconn
.new_flavor(flavor_data
)
6450 self
.assertEqual(result
, expected_result
)
6451 mock_reload_connection
.assert_called_once()
6452 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6453 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6454 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6455 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6456 name
=name1
, ram
=3, vcpus
=vcpus
, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6458 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6460 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6463 "_process_extended_config_of_flavor",
6464 new_callable
=CopyingMock(),
6466 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6467 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6468 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6469 def test_new_flavor_change_name_if_used_false_with_extended(
6471 mock_format_exception
,
6472 mock_reload_connection
,
6473 mock_change_flavor_name
,
6474 mock_extended_config_of_flavor
,
6475 mock_get_flavor_details
,
6477 """Create new flavor, change_name_if_used_false, there is extended."""
6479 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6480 expected_result
= self
.new_flavor
.id
6481 result
= self
.vimconn
.new_flavor(flavor_data
, False)
6482 self
.assertEqual(result
, expected_result
)
6483 mock_reload_connection
.assert_called_once()
6484 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6485 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6486 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6487 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6489 check_if_assert_not_called(
6490 [mock_change_flavor_name
, mock_format_exception
, self
.new_flavor
.set_keys
]
6493 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6496 "_process_extended_config_of_flavor",
6497 new_callable
=CopyingMock(),
6499 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6500 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6501 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6502 def test_new_flavor_change_name_if_used_true_without_extended(
6504 mock_format_exception
,
6505 mock_reload_connection
,
6506 mock_change_flavor_name
,
6507 mock_extended_config_of_flavor
,
6508 mock_get_flavor_details
,
6510 """Create new flavor without extended parameters."""
6512 mock_change_flavor_name
.return_value
= name1
6513 expected_result
= self
.new_flavor
.id
6514 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6515 result
= self
.vimconn
.new_flavor(flavor_data2
)
6516 self
.assertEqual(result
, expected_result
)
6517 mock_reload_connection
.assert_called_once()
6518 mock_change_flavor_name
.assert_called_once_with(
6519 name1
, name_suffix
, flavor_data2
6521 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6522 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6523 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6525 check_if_assert_not_called(
6527 self
.new_flavor
.set_keys
,
6528 mock_extended_config_of_flavor
,
6529 mock_format_exception
,
6533 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6536 "_process_extended_config_of_flavor",
6537 new_callable
=CopyingMock(),
6539 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6540 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6541 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6542 def test_new_flavor_reload_connection_exception(
6544 mock_format_exception
,
6545 mock_reload_connection
,
6546 mock_change_flavor_name
,
6547 mock_extended_config_of_flavor
,
6548 mock_get_flavor_details
,
6550 """Create new flavor, reload connection exception occurred."""
6551 error_msg
= "Can not connect to client APIs."
6552 error
= nvExceptions
.ClientException(error_msg
)
6553 mock_change_flavor_name
.return_value
= name1
6554 mock_reload_connection
.side_effect
= error
6555 with self
.assertRaises(Exception) as err
:
6556 self
.vimconn
.new_flavor(flavor_data2
)
6557 self
.assertEqual(str(err
.exception
), "Can not connect to client APIs.")
6558 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6559 call_mock_format_exception
= mock_format_exception
.call_args
6561 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6563 check_if_assert_not_called(
6565 mock_change_flavor_name
,
6566 mock_get_flavor_details
,
6567 mock_extended_config_of_flavor
,
6568 self
.vimconn
.nova
.flavors
.create
,
6572 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6575 "_process_extended_config_of_flavor",
6576 new_callable
=CopyingMock(autospec
=True),
6578 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6579 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6580 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6581 def test_new_flavor_flavor_data_without_name(
6583 mock_format_exception
,
6584 mock_reload_connection
,
6585 mock_change_flavor_name
,
6586 mock_extended_config_of_flavor
,
6587 mock_get_flavor_details
,
6589 """Create new flavor, flavor data does not have name."""
6596 self
.vimconn
.new_flavor(flavor_data3
)
6597 mock_format_exception
.assert_called_once()
6598 call_mock_format_exception
= mock_format_exception
.call_args
6600 str(call_mock_format_exception
[0][0]), str(KeyError(error_msg
))
6602 check_if_assert_not_called(
6604 mock_reload_connection
,
6605 mock_change_flavor_name
,
6606 mock_get_flavor_details
,
6607 mock_extended_config_of_flavor
,
6608 self
.vimconn
.nova
.flavors
.create
,
6612 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6615 "_process_extended_config_of_flavor",
6616 new_callable
=CopyingMock(),
6618 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6619 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6620 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6621 def test_new_flavor_change_flavor_name_has_extended_conflict_exception_recovered_in_retry(
6623 mock_format_exception
,
6624 mock_reload_connection
,
6625 mock_change_flavor_name
,
6626 mock_extended_config_of_flavor
,
6627 mock_get_flavor_details
,
6629 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is extended config."""
6631 error_msg
= "Conflict has occurred while creating flavor name."
6632 error2
= nvExceptions
.Conflict(error_msg
)
6633 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6634 expected_result
= self
.new_flavor
.id
6635 mock_get_flavor_details
.return_value
= (3, 8, {}, extended
)
6636 result
= self
.vimconn
.new_flavor(flavor_data2
)
6637 self
.assertEqual(result
, expected_result
)
6638 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6639 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6640 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6641 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6642 self
.assertEqual(mock_extended_config_of_flavor
.call_count
, 1)
6643 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6644 name
="sample-flavor-3",
6652 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6654 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6657 "_process_extended_config_of_flavor",
6658 new_callable
=CopyingMock(),
6660 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6661 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6662 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6663 def test_new_flavor_change_flavor_name_without_extended_conflict_exception_recovered_in_retry(
6665 mock_format_exception
,
6666 mock_reload_connection
,
6667 mock_change_flavor_name
,
6668 mock_extended_config_of_flavor
,
6669 mock_get_flavor_details
,
6671 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is not extended config."""
6673 error2
= nvExceptions
.Conflict(
6674 "Conflict has occurred while creating flavor name."
6676 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6677 expected_result
= self
.new_flavor
.id
6678 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6679 result
= self
.vimconn
.new_flavor(flavor_data2
)
6680 self
.assertEqual(result
, expected_result
)
6681 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6682 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6683 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6684 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6685 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6686 name
="sample-flavor-3",
6694 check_if_assert_not_called(
6696 self
.new_flavor
.set_keys
,
6697 mock_extended_config_of_flavor
,
6698 mock_format_exception
,
6702 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6705 "_process_extended_config_of_flavor",
6706 new_callable
=CopyingMock(),
6708 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6709 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6710 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6711 def test_new_flavor_change_flavor_name_conflict_exception_change_name_if_used_false(
6713 mock_format_exception
,
6714 mock_reload_connection
,
6715 mock_change_flavor_name
,
6716 mock_extended_config_of_flavor
,
6717 mock_get_flavor_details
,
6719 """Create new flavor, nvExceptions.Conflict occurred,
6720 change_name_if_used is false."""
6721 change_name_if_used
= False
6722 error_msg
= "Conflict has occurred while creating flavor name."
6723 error2
= nvExceptions
.Conflict(error_msg
)
6724 mock_get_flavor_details
.return_value
= (4, 8, {}, None)
6725 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6726 with self
.assertRaises(Exception) as err
:
6727 self
.vimconn
.new_flavor(flavor_data2
, change_name_if_used
)
6728 self
.assertEqual(str(err
.exception
), error_msg
)
6729 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6730 self
.vimconn
.nova
.flavors
.create
.assert_called_with(
6731 name
="sample-flavor",
6739 self
.assertEqual(mock_get_flavor_details
.call_count
, 3)
6740 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6741 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6742 check_if_assert_not_called(
6743 [mock_change_flavor_name
, mock_extended_config_of_flavor
]
6745 _call_mock_format_exception
= mock_format_exception
.call_args
6747 str(_call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6749 self
.assertEqual(mock_format_exception
.call_count
, 3)
6751 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6754 "_process_extended_config_of_flavor",
6755 new_callable
=CopyingMock(),
6757 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6758 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6759 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6760 def test_new_flavor_client_exception_occurred_change_name_if_used_true(
6762 mock_format_exception
,
6763 mock_reload_connection
,
6764 mock_change_flavor_name
,
6765 mock_extended_config_of_flavor
,
6766 mock_get_flavor_details
,
6768 """Create new flavor, nvExceptions.ClientException occurred,
6769 change_name_if_used is true."""
6770 error_msg
= "Connection failed."
6771 error2
= nvExceptions
.ClientException(error_msg
)
6772 mock_change_flavor_name
.side_effect
= [
6777 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6778 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6779 with self
.assertRaises(Exception) as err
:
6780 self
.vimconn
.new_flavor(flavor_data2
)
6782 str(err
.exception
), "Conflict has occurred while creating flavor name."
6784 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6785 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 1)
6786 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6788 _call_mock_nova_create_flavor
[0][1],
6791 "name": "sample-flavor-3",
6802 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6803 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6804 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6806 _call_mock_change_flavor
[0][0],
6810 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6813 self
.assertEqual(mock_change_flavor_name
.call_count
, 1)
6814 mock_extended_config_of_flavor
.assert_not_called()
6815 call_mock_format_exception
= mock_format_exception
.call_args
6817 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6819 self
.assertEqual(mock_format_exception
.call_count
, 1)
6821 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6824 "_process_extended_config_of_flavor",
6825 new_callable
=CopyingMock(),
6827 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6828 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6829 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6830 def test_new_flavor_change_flavor_name_conflict_exception_occurred_change_name_if_used_true(
6832 mock_format_exception
,
6833 mock_reload_connection
,
6834 mock_change_flavor_name
,
6835 mock_extended_config_of_flavor
,
6836 mock_get_flavor_details
,
6838 """Create new flavor, nvExceptions.Conflict occurred,
6839 change_name_if_used is true."""
6840 error_msg
= "Conflict has occurred while creating flavor name."
6841 error2
= nvExceptions
.Conflict(error_msg
)
6842 mock_change_flavor_name
.side_effect
= [
6847 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6848 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
6849 with self
.assertRaises(Exception) as err
:
6850 self
.vimconn
.new_flavor(flavor_data2
)
6851 self
.assertEqual(str(err
.exception
), error_msg
)
6852 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
6853 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
6854 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
6856 _call_mock_nova_create_flavor
[0][1],
6859 "name": "sample-flavor-3",
6870 _call_mock_nova_create_flavor
[1][1],
6873 "name": "sample-flavor-4",
6884 _call_mock_nova_create_flavor
[2][1],
6887 "name": "sample-flavor-5",
6897 self
.assertEqual(mock_reload_connection
.call_count
, 3)
6898 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
6900 _call_mock_change_flavor
[0][0],
6904 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6908 _call_mock_change_flavor
[1][0],
6912 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6916 _call_mock_change_flavor
[2][0],
6920 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
6923 self
.assertEqual(mock_change_flavor_name
.call_count
, 3)
6924 mock_extended_config_of_flavor
.assert_not_called()
6925 call_mock_format_exception
= mock_format_exception
.call_args
6927 str(call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
6929 self
.assertEqual(mock_format_exception
.call_count
, 1)
6931 def test_process_process_vio_numa_nodes_without_numa_with_extra_spec(self
):
6933 extra_specs
= {"hw:numa_nodes": "0"}
6934 expected_extra_spec
= {
6935 "vmware:latency_sensitivity_level": "high",
6936 "hw:numa_nodes": "0",
6938 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6939 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6941 def test_process_process_vio_numa_nodes_list_type_numa_nodes_empty_extra_spec(self
):
6942 numa_nodes
= [7, 9, 4]
6944 expected_extra_spec
= {
6945 "vmware:latency_sensitivity_level": "high",
6947 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6948 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6950 def test_process_process_vio_numa_nodes_with_numa_with_extra_spec(self
):
6952 extra_specs
= {"hw:numa_nodes": "5"}
6953 expected_extra_spec
= {
6954 "vmware:latency_sensitivity_level": "high",
6955 "hw:numa_nodes": "5",
6957 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6958 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6960 def test_process_process_vio_numa_nodes_none_numa_nodes(self
):
6962 extra_specs
= {"hw:numa_nodes": "None"}
6963 expected_extra_spec
= {
6964 "vmware:latency_sensitivity_level": "high",
6965 "hw:numa_nodes": "None",
6967 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6968 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6970 def test_process_process_vio_numa_nodes_invalid_type_extra_specs(self
):
6973 with self
.assertRaises(TypeError):
6974 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
6977 if __name__
== "__main__":