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.
27 from copy
import deepcopy
32 from mock
import MagicMock
, patch
33 from neutronclient
.v2_0
.client
import Client
34 from novaclient
import exceptions
as nvExceptions
35 from novaclient
.exceptions
import ClientException
, Conflict
36 from osm_ro_plugin
import vimconn
37 from osm_ro_plugin
.vimconn
import (
38 VimConnConnectionException
,
40 VimConnNotFoundException
,
42 from osm_rovim_openstack
.vimconn_openstack
import vimconnector
44 __author__
= "Igor D.C."
45 __date__
= "$23-aug-2017 23:59:59$"
47 # Variables Used in TestNewVmInstance Class
49 description
= "my firewall"
51 image_id
= "408b73-e9cc-5a6a-t270-82cc4811bd4a"
52 flavor_id
= "208b73-e9cc-5a6a-t270-82cc4811bd4a"
53 affinity_group_list
= []
58 {"size": 10, "image_id": image_id
},
61 availability_zone_index
= 0
62 availability_zone_list
= ["nova"]
63 floating_network_vim_id
= "108b73-e9cc-5a6a-t270-82cc4811bd4a"
64 net_id
= "83372685-f67f-49fd-8722-eabb7692fc22"
65 net2_id
= "46472685-f67f-49fd-8722-eabb7692fc22"
66 mac_address
= "00:00:5e:00:53:af"
67 port_id
= "03372685-f67f-49fd-8722-eabb7692fc22"
68 time_return_value
= 156570000
69 port2_id
= "17472685-f67f-49fd-8722-eabb7692fc22"
70 root_vol_id
= "tc408b73-r9cc-5a6a-a270-82cc4811bd4a"
72 volume_id
= "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"
73 volume_id2
= "o4e0e83-b9uu-4akk-a234-89cc4811bd4a"
74 volume_id3
= "44e0e83-t9uu-4akk-a234-p9cc4811bd4a"
75 virtual_mac_id
= "64e0e83-t9uu-4akk-a234-p9cc4811bd4a"
76 created_items_all_true
= {
77 f
"floating_ip:{floating_network_vim_id}": True,
78 f
"volume:{volume_id}": True,
79 f
"port:{port_id}": True,
83 # Variables used in TestNewFlavor Class
84 name1
= "sample-flavor"
87 "cpu-quota": {"limit": 3},
88 "mem-quota": {"limit": 1},
89 "mempage-size": "LARGE",
90 "cpu-pinning-policy": "DEDICATED",
91 "mem-policy": "STRICT",
110 class TestSfcOperations(unittest
.TestCase
):
111 @mock.patch("logging.getLogger", autospec
=True)
112 def setUp(self
, mock_logger
):
113 # Instantiate dummy VIM connector so we can test it
114 # It throws exception because of dummy parameters,
115 # We are disabling the logging of exception not to print them to console.
116 mock_logger
= logging
.getLogger()
117 mock_logger
.disabled
= True
118 self
.vimconn
= vimconnector(
131 create_sfc_port_pair
,
133 ingress_ports
=["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
134 egress_ports
=["230cdf1b-de37-4891-bc07-f9010cf1f967"],
136 # input to VIM connector
140 # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
142 if sfc_encap
is not None:
146 # what OpenStack is assumed to respond (patch OpenStack"s return value)
147 dict_from_neutron
= {
149 "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
152 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
153 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
154 "ingress": ingress_ports
[0] if len(ingress_ports
) else None,
155 "egress": egress_ports
[0] if len(egress_ports
) else None,
156 "service_function_parameters": {"correlation": correlation
},
159 create_sfc_port_pair
.return_value
= dict_from_neutron
161 # what the VIM connector is expected to
162 # send to OpenStack based on the input
166 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
167 "egress": "230cdf1b-de37-4891-bc07-f9010cf1f967",
168 "service_function_parameters": {"correlation": correlation
},
172 # call the VIM connector
173 if sfc_encap
is None:
174 result
= self
.vimconn
.new_sfi(name
, ingress_ports
, egress_ports
)
176 result
= self
.vimconn
.new_sfi(name
, ingress_ports
, egress_ports
, sfc_encap
)
178 # assert that the VIM connector made the expected call to OpenStack
179 create_sfc_port_pair
.assert_called_with(dict_to_neutron
)
180 # assert that the VIM connector had the expected result / return value
181 self
.assertEqual(result
, dict_from_neutron
["port_pair"]["id"])
183 def _test_new_sf(self
, create_sfc_port_pair_group
):
184 # input to VIM connector
187 "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
188 "12ba215e-3987-4892-bd3a-d0fd91eecf98",
189 "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
192 # what OpenStack is assumed to respond (patch OpenStack"s return value)
193 dict_from_neutron
= {
195 "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
198 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
199 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
200 "port_pairs": instances
,
202 "port_pair_group_parameters": {
204 "ppg_n_tuple_mapping": {
205 "ingress_n_tuple": {},
206 "egress_n_tuple": {},
211 create_sfc_port_pair_group
.return_value
= dict_from_neutron
213 # what the VIM connector is expected to
214 # send to OpenStack based on the input
219 "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
220 "12ba215e-3987-4892-bd3a-d0fd91eecf98",
221 "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
226 # call the VIM connector
227 result
= self
.vimconn
.new_sf(name
, instances
)
229 # assert that the VIM connector made the expected call to OpenStack
230 create_sfc_port_pair_group
.assert_called_with(dict_to_neutron
)
231 # assert that the VIM connector had the expected result / return value
232 self
.assertEqual(result
, dict_from_neutron
["port_pair_group"]["id"])
234 def _test_new_sfp(self
, create_sfc_port_chain
, sfc_encap
, spi
):
235 # input to VIM connector
238 "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
239 "00f23389-bdfa-43c2-8b16-5815f2582fa8",
242 "2314daec-c262-414a-86e3-69bb6fa5bc16",
243 "d8bfdb5d-195e-4f34-81aa-6135705317df",
246 # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
252 # what OpenStack is assumed to respond (patch OpenStack"s return value)
253 dict_from_neutron
= {
255 "id": "5bc05721-079b-4b6e-a235-47cac331cbb6",
258 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
259 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
260 "chain_id": chain_id
,
261 "flow_classifiers": classifications
,
262 "port_pair_groups": sfs
,
263 "chain_parameters": {"correlation": correlation
},
266 create_sfc_port_chain
.return_value
= dict_from_neutron
268 # what the VIM connector is expected to
269 # send to OpenStack based on the input
273 "flow_classifiers": [
274 "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
275 "00f23389-bdfa-43c2-8b16-5815f2582fa8",
277 "port_pair_groups": [
278 "2314daec-c262-414a-86e3-69bb6fa5bc16",
279 "d8bfdb5d-195e-4f34-81aa-6135705317df",
281 "chain_parameters": {"correlation": correlation
},
285 dict_to_neutron
["port_chain"]["chain_id"] = spi
287 # call the VIM connector
288 if sfc_encap
is None:
289 dict_to_neutron
["port_chain"]["chain_parameters"] = {"correlation": "mpls"}
291 result
= self
.vimconn
.new_sfp(
292 name
, classifications
, sfs
, sfc_encap
=False
295 result
= self
.vimconn
.new_sfp(
296 name
, classifications
, sfs
, sfc_encap
=False, spi
=spi
300 result
= self
.vimconn
.new_sfp(name
, classifications
, sfs
, sfc_encap
)
302 result
= self
.vimconn
.new_sfp(
303 name
, classifications
, sfs
, sfc_encap
, spi
306 # assert that the VIM connector made the expected call to OpenStack
307 create_sfc_port_chain
.assert_called_with(dict_to_neutron
)
308 # assert that the VIM connector had the expected result / return value
309 self
.assertEqual(result
, dict_from_neutron
["port_chain"]["id"])
311 def _test_new_classification(self
, create_sfc_flow_classifier
, ctype
):
312 # input to VIM connector
313 name
= "osm_classification"
316 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
318 "source_ip_prefix": "192.168.2.0/24",
319 "source_port_range_max": 99,
320 "source_port_range_min": 50,
323 # what OpenStack is assumed to respond (patch OpenStack"s return value)
324 dict_from_neutron
= {"flow_classifier": copy
.copy(definition
)}
325 dict_from_neutron
["flow_classifier"][
327 ] = "7735ec2c-fddf-4130-9712-32ed2ab6a372"
328 dict_from_neutron
["flow_classifier"]["name"] = name
329 dict_from_neutron
["flow_classifier"]["description"] = ""
330 dict_from_neutron
["flow_classifier"][
332 ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
333 dict_from_neutron
["flow_classifier"][
335 ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
336 create_sfc_flow_classifier
.return_value
= dict_from_neutron
338 # what the VIM connector is expected to
339 # send to OpenStack based on the input
340 dict_to_neutron
= {"flow_classifier": copy
.copy(definition
)}
341 dict_to_neutron
["flow_classifier"]["name"] = "osm_classification"
343 # call the VIM connector
344 result
= self
.vimconn
.new_classification(name
, ctype
, definition
)
346 # assert that the VIM connector made the expected call to OpenStack
347 create_sfc_flow_classifier
.assert_called_with(dict_to_neutron
)
348 # assert that the VIM connector had the expected result / return value
349 self
.assertEqual(result
, dict_from_neutron
["flow_classifier"]["id"])
351 @mock.patch
.object(Client
, "create_sfc_flow_classifier")
352 def test_new_classification(self
, create_sfc_flow_classifier
):
353 self
._test
_new
_classification
(
354 create_sfc_flow_classifier
, "legacy_flow_classifier"
357 @mock.patch
.object(Client
, "create_sfc_flow_classifier")
358 def test_new_classification_unsupported_type(self
, create_sfc_flow_classifier
):
360 vimconn
.VimConnNotSupportedException
,
361 self
._test
_new
_classification
,
362 create_sfc_flow_classifier
,
366 @mock.patch
.object(Client
, "create_sfc_port_pair")
367 def test_new_sfi_with_sfc_encap(self
, create_sfc_port_pair
):
368 self
._test
_new
_sfi
(create_sfc_port_pair
, True)
370 @mock.patch
.object(Client
, "create_sfc_port_pair")
371 def test_new_sfi_without_sfc_encap(self
, create_sfc_port_pair
):
372 self
._test
_new
_sfi
(create_sfc_port_pair
, False)
374 @mock.patch
.object(Client
, "create_sfc_port_pair")
375 def test_new_sfi_default_sfc_encap(self
, create_sfc_port_pair
):
376 self
._test
_new
_sfi
(create_sfc_port_pair
, None)
378 @mock.patch
.object(Client
, "create_sfc_port_pair")
379 def test_new_sfi_bad_ingress_ports(self
, create_sfc_port_pair
):
381 "5311c75d-d718-4369-bbda-cdcc6da60fcc",
382 "a0273f64-82c9-11e7-b08f-6328e53f0fa7",
385 vimconn
.VimConnNotSupportedException
,
387 create_sfc_port_pair
,
389 ingress_ports
=ingress_ports
,
393 vimconn
.VimConnNotSupportedException
,
395 create_sfc_port_pair
,
397 ingress_ports
=ingress_ports
,
400 @mock.patch
.object(Client
, "create_sfc_port_pair")
401 def test_new_sfi_bad_egress_ports(self
, create_sfc_port_pair
):
403 "230cdf1b-de37-4891-bc07-f9010cf1f967",
404 "b41228fe-82c9-11e7-9b44-17504174320b",
407 vimconn
.VimConnNotSupportedException
,
409 create_sfc_port_pair
,
411 egress_ports
=egress_ports
,
415 vimconn
.VimConnNotSupportedException
,
417 create_sfc_port_pair
,
419 egress_ports
=egress_ports
,
422 @mock.patch
.object(vimconnector
, "get_sfi")
423 @mock.patch
.object(Client
, "create_sfc_port_pair_group")
424 def test_new_sf(self
, create_sfc_port_pair_group
, get_sfi
):
425 get_sfi
.return_value
= {"sfc_encap": True}
426 self
._test
_new
_sf
(create_sfc_port_pair_group
)
428 @mock.patch
.object(vimconnector
, "get_sfi")
429 @mock.patch
.object(Client
, "create_sfc_port_pair_group")
430 def test_new_sf_inconsistent_sfc_encap(self
, create_sfc_port_pair_group
, get_sfi
):
431 get_sfi
.return_value
= {"sfc_encap": "nsh"}
433 vimconn
.VimConnNotSupportedException
,
435 create_sfc_port_pair_group
,
438 @mock.patch
.object(Client
, "create_sfc_port_chain")
439 def test_new_sfp_with_sfc_encap(self
, create_sfc_port_chain
):
440 self
._test
_new
_sfp
(create_sfc_port_chain
, True, None)
442 @mock.patch
.object(Client
, "create_sfc_port_chain")
443 def test_new_sfp_without_sfc_encap(self
, create_sfc_port_chain
):
444 self
._test
_new
_sfp
(create_sfc_port_chain
, None, None)
445 self
._test
_new
_sfp
(create_sfc_port_chain
, None, 25)
447 @mock.patch
.object(Client
, "create_sfc_port_chain")
448 def test_new_sfp_default_sfc_encap(self
, create_sfc_port_chain
):
449 self
._test
_new
_sfp
(create_sfc_port_chain
, None, None)
451 @mock.patch
.object(Client
, "create_sfc_port_chain")
452 def test_new_sfp_with_sfc_encap_spi(self
, create_sfc_port_chain
):
453 self
._test
_new
_sfp
(create_sfc_port_chain
, True, 25)
455 @mock.patch
.object(Client
, "create_sfc_port_chain")
456 def test_new_sfp_default_sfc_encap_spi(self
, create_sfc_port_chain
):
457 self
._test
_new
_sfp
(create_sfc_port_chain
, None, 25)
459 @mock.patch
.object(Client
, "list_sfc_flow_classifiers")
460 def test_get_classification_list(self
, list_sfc_flow_classifiers
):
461 # what OpenStack is assumed to return to the VIM connector
462 list_sfc_flow_classifiers
.return_value
= {
463 "flow_classifiers": [
465 "source_port_range_min": 2000,
466 "destination_ip_prefix": "192.168.3.0/24",
471 "source_port_range_max": 2000,
472 "destination_port_range_min": 3000,
473 "source_ip_prefix": "192.168.2.0/24",
474 "logical_destination_port": None,
475 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
476 "destination_port_range_max": None,
477 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
478 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
479 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
485 # call the VIM connector
486 filter_dict
= {"protocol": "tcp", "ethertype": "IPv4"}
487 result
= self
.vimconn
.get_classification_list(filter_dict
.copy())
489 # assert that VIM connector called OpenStack with the expected filter
490 list_sfc_flow_classifiers
.assert_called_with(**filter_dict
)
491 # assert that the VIM connector successfully
492 # translated and returned the OpenStack result
497 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
500 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
501 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
502 "ctype": "legacy_flow_classifier",
504 "source_port_range_min": 2000,
505 "destination_ip_prefix": "192.168.3.0/24",
509 "source_port_range_max": 2000,
510 "destination_port_range_min": 3000,
511 "source_ip_prefix": "192.168.2.0/24",
512 "logical_destination_port": None,
513 "destination_port_range_max": None,
514 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
520 def _test_get_sfi_list(self
, list_port_pair
, correlation
, sfc_encap
):
521 # what OpenStack is assumed to return to the VIM connector
522 list_port_pair
.return_value
= {
525 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
527 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
528 "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
529 "service_function_parameters": {"correlation": correlation
},
530 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
531 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
537 # call the VIM connector
538 filter_dict
= {"name": "osm_sfi", "description": ""}
539 result
= self
.vimconn
.get_sfi_list(filter_dict
.copy())
541 # assert that VIM connector called OpenStack with the expected filter
542 list_port_pair
.assert_called_with(**filter_dict
)
543 # assert that the VIM connector successfully
544 # translated and returned the OpenStack result
549 "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
551 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
552 "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
553 "sfc_encap": sfc_encap
,
554 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
555 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
561 @mock.patch
.object(Client
, "list_sfc_port_pairs")
562 def test_get_sfi_list_with_sfc_encap(self
, list_sfc_port_pairs
):
563 self
._test
_get
_sfi
_list
(list_sfc_port_pairs
, "nsh", True)
565 @mock.patch
.object(Client
, "list_sfc_port_pairs")
566 def test_get_sfi_list_without_sfc_encap(self
, list_sfc_port_pairs
):
567 self
._test
_get
_sfi
_list
(list_sfc_port_pairs
, None, False)
569 @mock.patch
.object(Client
, "list_sfc_port_pair_groups")
570 def test_get_sf_list(self
, list_sfc_port_pair_groups
):
571 # what OpenStack is assumed to return to the VIM connector
572 list_sfc_port_pair_groups
.return_value
= {
573 "port_pair_groups": [
576 "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
577 "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
580 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
581 "port_pair_group_parameters": {},
582 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
583 "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
589 # call the VIM connector
590 filter_dict
= {"name": "osm_sf", "description": ""}
591 result
= self
.vimconn
.get_sf_list(filter_dict
.copy())
593 # assert that VIM connector called OpenStack with the expected filter
594 list_sfc_port_pair_groups
.assert_called_with(**filter_dict
)
595 # assert that the VIM connector successfully
596 # translated and returned the OpenStack result
602 "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
603 "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
606 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
607 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
608 "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
614 def _test_get_sfp_list(self
, list_sfc_port_chains
, correlation
, sfc_encap
):
615 # what OpenStack is assumed to return to the VIM connector
616 list_sfc_port_chains
.return_value
= {
619 "port_pair_groups": [
620 "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
621 "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
623 "flow_classifiers": [
624 "1333c2f4-82d7-11e7-a5df-9327f33d104e",
625 "1387ab44-82d7-11e7-9bb0-476337183905",
628 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
629 "chain_parameters": {"correlation": correlation
},
631 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
632 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
638 # call the VIM connector
639 filter_dict
= {"name": "osm_sfp", "description": ""}
640 result
= self
.vimconn
.get_sfp_list(filter_dict
.copy())
642 # assert that VIM connector called OpenStack with the expected filter
643 list_sfc_port_chains
.assert_called_with(**filter_dict
)
644 # assert that the VIM connector successfully
645 # translated and returned the OpenStack result
650 "service_functions": [
651 "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
652 "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
655 "1333c2f4-82d7-11e7-a5df-9327f33d104e",
656 "1387ab44-82d7-11e7-9bb0-476337183905",
659 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
660 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
661 "sfc_encap": sfc_encap
,
663 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
669 @mock.patch
.object(Client
, "list_sfc_port_chains")
670 def test_get_sfp_list_with_sfc_encap(self
, list_sfc_port_chains
):
671 self
._test
_get
_sfp
_list
(list_sfc_port_chains
, "nsh", True)
673 @mock.patch
.object(Client
, "list_sfc_port_chains")
674 def test_get_sfp_list_without_sfc_encap(self
, list_sfc_port_chains
):
675 self
._test
_get
_sfp
_list
(list_sfc_port_chains
, None, False)
677 @mock.patch
.object(Client
, "list_sfc_flow_classifiers")
678 def test_get_classification(self
, list_sfc_flow_classifiers
):
679 # what OpenStack is assumed to return to the VIM connector
680 list_sfc_flow_classifiers
.return_value
= {
681 "flow_classifiers": [
683 "source_port_range_min": 2000,
684 "destination_ip_prefix": "192.168.3.0/24",
689 "source_port_range_max": 2000,
690 "destination_port_range_min": 3000,
691 "source_ip_prefix": "192.168.2.0/24",
692 "logical_destination_port": None,
693 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
694 "destination_port_range_max": None,
695 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
696 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
697 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
703 # call the VIM connector
704 result
= self
.vimconn
.get_classification("22198366-d4e8-4d6b-b4d2-637d5d6cbb7d")
706 # assert that VIM connector called OpenStack with the expected filter
707 list_sfc_flow_classifiers
.assert_called_with(
708 id="22198366-d4e8-4d6b-b4d2-637d5d6cbb7d"
710 # assert that VIM connector successfully returned the OpenStack result
714 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
717 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
718 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
719 "ctype": "legacy_flow_classifier",
721 "source_port_range_min": 2000,
722 "destination_ip_prefix": "192.168.3.0/24",
726 "source_port_range_max": 2000,
727 "destination_port_range_min": 3000,
728 "source_ip_prefix": "192.168.2.0/24",
729 "logical_destination_port": None,
730 "destination_port_range_max": None,
731 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
736 @mock.patch
.object(Client
, "list_sfc_flow_classifiers")
737 def test_get_classification_many_results(self
, list_sfc_flow_classifiers
):
738 # what OpenStack is assumed to return to the VIM connector
739 list_sfc_flow_classifiers
.return_value
= {
740 "flow_classifiers": [
742 "source_port_range_min": 2000,
743 "destination_ip_prefix": "192.168.3.0/24",
748 "source_port_range_max": 2000,
749 "destination_port_range_min": 3000,
750 "source_ip_prefix": "192.168.2.0/24",
751 "logical_destination_port": None,
752 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
753 "destination_port_range_max": None,
754 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
755 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
756 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
760 "source_port_range_min": 1000,
761 "destination_ip_prefix": "192.168.3.0/24",
766 "source_port_range_max": 1000,
767 "destination_port_range_min": 3000,
768 "source_ip_prefix": "192.168.2.0/24",
769 "logical_destination_port": None,
770 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
771 "destination_port_range_max": None,
772 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
773 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
774 "id": "3196bafc-82dd-11e7-a205-9bf6c14b0721",
780 # call the VIM connector
782 vimconn
.VimConnConflictException
,
783 self
.vimconn
.get_classification
,
784 "3196bafc-82dd-11e7-a205-9bf6c14b0721",
787 # assert the VIM connector called OpenStack with the expected filter
788 list_sfc_flow_classifiers
.assert_called_with(
789 id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
792 @mock.patch
.object(Client
, "list_sfc_flow_classifiers")
793 def test_get_classification_no_results(self
, list_sfc_flow_classifiers
):
794 # what OpenStack is assumed to return to the VIM connector
795 list_sfc_flow_classifiers
.return_value
= {"flow_classifiers": []}
797 # call the VIM connector
799 vimconn
.VimConnNotFoundException
,
800 self
.vimconn
.get_classification
,
801 "3196bafc-82dd-11e7-a205-9bf6c14b0721",
804 # assert the VIM connector called OpenStack with the expected filter
805 list_sfc_flow_classifiers
.assert_called_with(
806 id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
809 @mock.patch
.object(Client
, "list_sfc_port_pairs")
810 def test_get_sfi(self
, list_sfc_port_pairs
):
811 # what OpenStack is assumed to return to the VIM connector
812 list_sfc_port_pairs
.return_value
= {
815 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
817 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
818 "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
819 "service_function_parameters": {"correlation": "nsh"},
820 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
821 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
827 # call the VIM connector
828 result
= self
.vimconn
.get_sfi("c121ebdd-7f2d-4213-b933-3325298a6966")
830 # assert the VIM connector called OpenStack with the expected filter
831 list_sfc_port_pairs
.assert_called_with(
832 id="c121ebdd-7f2d-4213-b933-3325298a6966"
834 # assert the VIM connector successfully returned the OpenStack result
838 "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
839 "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
842 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
843 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
844 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
849 @mock.patch
.object(Client
, "list_sfc_port_pairs")
850 def test_get_sfi_many_results(self
, list_sfc_port_pairs
):
851 # what OpenStack is assumed to return to the VIM connector
852 list_sfc_port_pairs
.return_value
= {
855 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
857 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
858 "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
859 "service_function_parameters": {"correlation": "nsh"},
860 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
861 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
865 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
867 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
868 "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
869 "service_function_parameters": {"correlation": "nsh"},
870 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
871 "id": "c0436d92-82db-11e7-8f9c-5fa535f1261f",
877 # call the VIM connector
879 vimconn
.VimConnConflictException
,
880 self
.vimconn
.get_sfi
,
881 "c0436d92-82db-11e7-8f9c-5fa535f1261f",
884 # assert that VIM connector called OpenStack with the expected filter
885 list_sfc_port_pairs
.assert_called_with(
886 id="c0436d92-82db-11e7-8f9c-5fa535f1261f"
889 @mock.patch
.object(Client
, "list_sfc_port_pairs")
890 def test_get_sfi_no_results(self
, list_sfc_port_pairs
):
891 # what OpenStack is assumed to return to the VIM connector
892 list_sfc_port_pairs
.return_value
= {"port_pairs": []}
894 # call the VIM connector
896 vimconn
.VimConnNotFoundException
,
897 self
.vimconn
.get_sfi
,
898 "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
901 # assert that VIM connector called OpenStack with the expected filter
902 list_sfc_port_pairs
.assert_called_with(
903 id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
906 @mock.patch
.object(Client
, "list_sfc_port_pair_groups")
907 def test_get_sf(self
, list_sfc_port_pair_groups
):
908 # what OpenStack is assumed to return to the VIM connector
909 list_sfc_port_pair_groups
.return_value
= {
910 "port_pair_groups": [
912 "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
914 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
915 "port_pair_group_parameters": {},
916 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
917 "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
923 # call the VIM connector
924 result
= self
.vimconn
.get_sf("b22892fc-82d9-11e7-ae85-0fea6a3b3757")
926 # assert that VIM connector called OpenStack with the expected filter
927 list_sfc_port_pair_groups
.assert_called_with(
928 id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
930 # assert that VIM connector successfully returned the OpenStack result
935 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
936 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
937 "sfis": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
938 "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
943 @mock.patch
.object(Client
, "list_sfc_port_pair_groups")
944 def test_get_sf_many_results(self
, list_sfc_port_pair_groups
):
945 # what OpenStack is assumed to return to the VIM connector
946 list_sfc_port_pair_groups
.return_value
= {
947 "port_pair_groups": [
949 "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
951 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
952 "port_pair_group_parameters": {},
953 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
954 "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
958 "port_pairs": ["0d63799c-82d6-11e7-8deb-a746bb3ae9f5"],
960 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
961 "port_pair_group_parameters": {},
962 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
963 "id": "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
969 # call the VIM connector
971 vimconn
.VimConnConflictException
,
973 "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
976 # assert that VIM connector called OpenStack with the expected filter
977 list_sfc_port_pair_groups
.assert_called_with(
978 id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
981 @mock.patch
.object(Client
, "list_sfc_port_pair_groups")
982 def test_get_sf_no_results(self
, list_sfc_port_pair_groups
):
983 # what OpenStack is assumed to return to the VIM connector
984 list_sfc_port_pair_groups
.return_value
= {"port_pair_groups": []}
986 # call the VIM connector
988 vimconn
.VimConnNotFoundException
,
990 "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
993 # assert that VIM connector called OpenStack with the expected filter
994 list_sfc_port_pair_groups
.assert_called_with(
995 id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
998 @mock.patch
.object(Client
, "list_sfc_port_chains")
999 def test_get_sfp(self
, list_sfc_port_chains
):
1000 # what OpenStack is assumed to return to the VIM connector
1001 list_sfc_port_chains
.return_value
= {
1004 "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1005 "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1007 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1008 "chain_parameters": {"correlation": "nsh"},
1010 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1011 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
1017 # call the VIM connector
1018 result
= self
.vimconn
.get_sfp("821bc9be-82d7-11e7-8ce3-23a08a27ab47")
1020 # assert that VIM connector called OpenStack with the expected filter
1021 list_sfc_port_chains
.assert_called_with(
1022 id="821bc9be-82d7-11e7-8ce3-23a08a27ab47"
1024 # assert that VIM connector successfully returned the OpenStack result
1028 "service_functions": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1029 "classifications": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1031 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1032 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1035 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
1040 @mock.patch
.object(Client
, "list_sfc_port_chains")
1041 def test_get_sfp_many_results(self
, list_sfc_port_chains
):
1042 # what OpenStack is assumed to return to the VIM connector
1043 list_sfc_port_chains
.return_value
= {
1046 "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1047 "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1049 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1050 "chain_parameters": {"correlation": "nsh"},
1052 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1053 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
1057 "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1058 "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1060 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1061 "chain_parameters": {"correlation": "nsh"},
1063 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1064 "id": "5d002f38-82de-11e7-a770-f303f11ce66a",
1070 # call the VIM connector
1072 vimconn
.VimConnConflictException
,
1073 self
.vimconn
.get_sfp
,
1074 "5d002f38-82de-11e7-a770-f303f11ce66a",
1077 # assert that VIM connector called OpenStack with the expected filter
1078 list_sfc_port_chains
.assert_called_with(
1079 id="5d002f38-82de-11e7-a770-f303f11ce66a"
1082 @mock.patch
.object(Client
, "list_sfc_port_chains")
1083 def test_get_sfp_no_results(self
, list_sfc_port_chains
):
1084 # what OpenStack is assumed to return to the VIM connector
1085 list_sfc_port_chains
.return_value
= {"port_chains": []}
1087 # call the VIM connector
1089 vimconn
.VimConnNotFoundException
,
1090 self
.vimconn
.get_sfp
,
1091 "5d002f38-82de-11e7-a770-f303f11ce66a",
1094 # assert that VIM connector called OpenStack with the expected filter
1095 list_sfc_port_chains
.assert_called_with(
1096 id="5d002f38-82de-11e7-a770-f303f11ce66a"
1099 @mock.patch
.object(Client
, "delete_sfc_flow_classifier")
1100 def test_delete_classification(self
, delete_sfc_flow_classifier
):
1101 result
= self
.vimconn
.delete_classification(
1102 "638f957c-82df-11e7-b7c8-132706021464"
1104 delete_sfc_flow_classifier
.assert_called_with(
1105 "638f957c-82df-11e7-b7c8-132706021464"
1107 self
.assertEqual(result
, "638f957c-82df-11e7-b7c8-132706021464")
1109 @mock.patch
.object(Client
, "delete_sfc_port_pair")
1110 def test_delete_sfi(self
, delete_sfc_port_pair
):
1111 result
= self
.vimconn
.delete_sfi("638f957c-82df-11e7-b7c8-132706021464")
1112 delete_sfc_port_pair
.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
1113 self
.assertEqual(result
, "638f957c-82df-11e7-b7c8-132706021464")
1115 @mock.patch
.object(Client
, "delete_sfc_port_pair_group")
1116 def test_delete_sf(self
, delete_sfc_port_pair_group
):
1117 result
= self
.vimconn
.delete_sf("638f957c-82df-11e7-b7c8-132706021464")
1118 delete_sfc_port_pair_group
.assert_called_with(
1119 "638f957c-82df-11e7-b7c8-132706021464"
1121 self
.assertEqual(result
, "638f957c-82df-11e7-b7c8-132706021464")
1123 @mock.patch
.object(Client
, "delete_sfc_port_chain")
1124 def test_delete_sfp(self
, delete_sfc_port_chain
):
1125 result
= self
.vimconn
.delete_sfp("638f957c-82df-11e7-b7c8-132706021464")
1126 delete_sfc_port_chain
.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
1127 self
.assertEqual(result
, "638f957c-82df-11e7-b7c8-132706021464")
1131 def __init__(self
, s
):
1138 class CopyingMock(MagicMock
):
1139 def __call__(self
, *args
, **kwargs
):
1140 args
= deepcopy(args
)
1141 kwargs
= deepcopy(kwargs
)
1142 return super(CopyingMock
, self
).__call
__(*args
, **kwargs
)
1145 class TestNewVmInstance(unittest
.TestCase
):
1146 @patch("logging.getLogger", autospec
=True)
1147 def setUp(self
, mock_logger
):
1148 # Instantiate dummy VIM connector so we can test it
1149 # It throws exception because of dummy parameters,
1150 # We are disabling the logging of exception not to print them to console.
1151 mock_logger
= logging
.getLogger()
1152 mock_logger
.disabled
= True
1153 self
.vimconn
= vimconnector(
1163 self
.vimconn
.neutron
= CopyingMock()
1164 self
.vimconn
.nova
= CopyingMock()
1165 self
.vimconn
.cinder
= CopyingMock()
1166 self
.server
= MagicMock(object, autospec
=True)
1167 self
.server
.tenant_id
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
1168 self
.server
.id = "908b73-e9cc-5a6a-t270-82cc4811bd4a"
1169 self
.vimconn
.config
["security_groups"] = "default"
1170 self
.vimconn
.config
["keypair"] = "my_keypair"
1171 self
.vimconn
.security_groups_id
= "12345"
1172 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.32"
1173 self
.vimconn
.logger
= CopyingMock()
1175 @patch.object(vimconnector
, "_get_ids_from_name")
1176 def test_prepare_port_dict_security_security_groups_exists_in_config(
1179 """In VIM config security_groups exists, net port_security is True
1180 no_port_security_extension does not exist.
1182 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1183 net
= {"port_security": True}
1185 result_dict
= {"security_groups": "12345"}
1187 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1188 self
.assertDictEqual(result_dict
, port_dict
)
1189 mock_get_ids
.assert_not_called()
1191 @patch.object(vimconnector
, "_get_ids_from_name")
1192 def test_prepare_port_dict_security_security_groups_exists_in_config_no_security_groups_id(
1195 """In VIM config Security_groups exists, net port_security is True, vim security_groups_id does not exist,
1196 no_port_security_extension does not exist.
1198 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1199 self
.vimconn
.security_groups_id
= None
1200 net
= {"port_security": True}
1202 result_dict
= {"security_groups": None}
1204 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1205 self
.assertDictEqual(result_dict
, port_dict
)
1206 mock_get_ids
.assert_called()
1208 @patch.object(vimconnector
, "_get_ids_from_name")
1209 def test_prepare_port_dict_security_security_groups_exists_security_extension_true_in_config(
1212 """In VIM config security_groups exists, net port_security is True, in VIM security_groups_id exists,
1213 no_port_security_extension set to True.
1215 self
.vimconn
.config
= {
1216 "security_groups": "example_security_group",
1217 "no_port_security_extension": True,
1219 net
= {"port_security": True}
1223 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1224 self
.assertDictEqual(result_dict
, port_dict
)
1225 mock_get_ids
.assert_not_called()
1227 @patch.object(vimconnector
, "_get_ids_from_name")
1228 def test_prepare_port_dict_security_no_security_groups_in_config(
1231 """In VIM config security_group does not exist, net port_security True, in VIM security_groups_id exists,
1232 no_port_security_extension does not exist."""
1233 self
.vimconn
.config
= {}
1234 net
= {"port_security": True}
1238 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1239 self
.assertDictEqual(result_dict
, port_dict
)
1240 mock_get_ids
.assert_not_called()
1242 @patch.object(vimconnector
, "_get_ids_from_name")
1243 def test_prepare_port_dict_security_no_security_groups_security_extension_true_in_config(
1246 """Security_group does not exist, net port_security is True, in VIM security_groups_id exists,
1247 no_port_security_extension set to True."""
1248 self
.vimconn
.config
= {"no_port_security_extension": True}
1249 net
= {"port_security": True}
1253 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1254 self
.assertDictEqual(result_dict
, port_dict
)
1255 mock_get_ids
.assert_not_called()
1257 @patch.object(vimconnector
, "_get_ids_from_name")
1258 def test_prepare_port_dict_security_security_groups_exists_net_port_security_false(
1261 """In VIM config security_group exists, net port_security False, security_groups_id exists,
1262 no_port_security_extension does not exist."""
1263 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1264 net
= {"port_security": False}
1268 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1269 self
.assertDictEqual(result_dict
, port_dict
)
1270 mock_get_ids
.assert_not_called()
1272 @patch.object(vimconnector
, "_get_ids_from_name")
1273 def test_prepare_port_dict_security_net_port_security_false_port_security_extension_true(
1276 """In VIM config security_group exists, net port_security False, security_groups_id exists,
1277 no_port_security_extension set to True."""
1278 self
.vimconn
.config
= {
1279 "security_groups": "example_security_group",
1280 "no_port_security_extension": True,
1282 net
= {"port_security": False}
1286 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1287 self
.assertDictEqual(result_dict
, port_dict
)
1288 mock_get_ids
.assert_not_called()
1290 def test_prepare_port_dict_binding_net_type_virtual(self
):
1291 """net type is virtual."""
1292 net
= {"type": "virtual"}
1295 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1296 self
.assertDictEqual(result_dict
, port_dict
)
1298 def test_prepare_port_dict_binding_net_type_vf(self
):
1299 """net type is VF, vim_type is not VIO."""
1300 net
= {"type": "VF"}
1301 self
.vimconn
.vim_type
= None
1303 result_dict
= {"binding:vnic_type": "direct"}
1304 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1305 self
.assertDictEqual(port_dict
, result_dict
)
1307 def test_prepare_port_dict_binding_net_type_sriov_vim_type_vio(self
):
1308 """net type is SR-IOV, vim_type is VIO."""
1309 net
= {"type": "SR-IOV"}
1310 self
.vimconn
.vim_type
= "VIO"
1313 "binding:vnic_type": "direct",
1314 "port_security_enabled": False,
1315 "provider_security_groups": [],
1316 "security_groups": [],
1318 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1319 self
.assertDictEqual(port_dict
, result_dict
)
1321 def test_prepare_port_dict_binding_net_type_passthrough(self
):
1322 """net type is pci-passthrough."""
1323 net
= {"type": "PCI-PASSTHROUGH"}
1326 "binding:vnic_type": "direct-physical",
1328 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1329 self
.assertDictEqual(port_dict
, result_dict
)
1331 def test_prepare_port_dict_binding_no_net_type(self
):
1332 """net type is missing."""
1335 with self
.assertRaises(VimConnException
) as err
:
1336 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1337 self
.assertEqual(str(err
.exception
), "Type is missing in the network details.")
1339 def test_set_fixed_ip(self
):
1340 """new_port has fixed ip."""
1344 "fixed_ips": [{"ip_address": "10.1.2.3"}, {"ip_address": "20.1.2.3"}]
1347 result
= {"ip": "10.1.2.3"}
1348 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1349 self
.assertDictEqual(net
, result
)
1351 def test_set_fixed_ip_no_fixed_ip(self
):
1352 """new_port does not have fixed ip."""
1354 new_port
= {"port": {}}
1355 result
= {"ip": None}
1356 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1357 self
.assertDictEqual(net
, result
)
1359 def test_set_fixed_ip_raise_exception(self
):
1360 """new_port does not have port details."""
1363 with self
.assertRaises(Exception) as err
:
1364 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1365 self
.assertEqual(type(err
.exception
), KeyError)
1367 def test_prepare_port_dict_mac_ip_addr(self
):
1368 """mac address and ip address exist."""
1370 "mac_address": mac_address
,
1371 "ip_address": "10.0.1.5",
1375 "mac_address": mac_address
,
1376 "fixed_ips": [{"ip_address": "10.0.1.5"}],
1378 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
1379 self
.assertDictEqual(port_dict
, result_dict
)
1381 def test_prepare_port_dict_mac_ip_addr_no_mac_and_ip(self
):
1382 """mac address and ip address does not exist."""
1386 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
1387 self
.assertDictEqual(port_dict
, result_dict
)
1389 def test_create_new_port(self
):
1390 """new port has id and mac address."""
1394 "mac_address": mac_address
,
1397 self
.vimconn
.neutron
.create_port
.return_value
= new_port
1398 net
, port_dict
, created_items
= {}, {}, {}
1399 expected_result
= new_port
1401 "mac_adress": mac_address
,
1404 expected_created_items
= {f
"port:{port_id}": True}
1405 result
= self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1406 self
.assertDictEqual(result
, expected_result
)
1407 self
.assertEqual(net
, expected_net
)
1408 self
.assertEqual(created_items
, expected_created_items
)
1409 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1411 def test_create_new_port_without_mac_or_id(self
):
1412 """new port does not have mac address or ID."""
1414 self
.vimconn
.neutron
.create_port
.return_value
= new_port
1415 net
, port_dict
, created_items
= {}, {}, {}
1416 with self
.assertRaises(KeyError):
1417 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1418 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1420 def test_create_new_port_neutron_create_port_raises_exception(self
):
1421 """Neutron create port raises exception."""
1422 self
.vimconn
.neutron
.create_port
.side_effect
= VimConnException(
1423 "New port is not created."
1425 net
, port_dict
, created_items
= {}, {}, {}
1426 with self
.assertRaises(VimConnException
):
1427 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1428 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1430 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1431 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1432 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1433 @patch.object(vimconnector
, "_create_new_port")
1434 @patch.object(vimconnector
, "_set_fixed_ip")
1435 def test_create_port(
1438 mock_create_new_port
,
1439 mock_prepare_port_dict_mac_ip_addr
,
1440 mock_prepare_port_dict_binding
,
1441 mock_prepare_port_dict_security_groups
,
1443 """Net has name, type, net-id."""
1447 "name": "management",
1454 "mac_address": mac_address
,
1455 "name": "management",
1456 "fixed_ips": [{"ip_address": ip_addr1
}],
1459 mock_create_new_port
.return_value
= new_port
1462 "tag": "management",
1465 "network_id": net_id
,
1466 "name": "management",
1467 "admin_state_up": True,
1470 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1471 net
, name
, created_items
1474 self
.assertDictEqual(new_port_result
, new_port
)
1475 self
.assertDictEqual(port_result
, expected_port
)
1477 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1478 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1479 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1480 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1481 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1483 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1484 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1485 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1486 @patch.object(vimconnector
, "_create_new_port")
1487 @patch.object(vimconnector
, "_set_fixed_ip")
1488 def test_create_port_no_port_name(
1491 mock_create_new_port
,
1492 mock_prepare_port_dict_mac_ip_addr
,
1493 mock_prepare_port_dict_binding
,
1494 mock_prepare_port_dict_security_groups
,
1496 """Net has no name."""
1505 "mac_address": mac_address
,
1507 "fixed_ips": [{"ip_address": ip_addr1
}],
1510 mock_create_new_port
.return_value
= new_port
1516 "network_id": net_id
,
1517 "admin_state_up": True,
1521 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1522 net
, name
, created_items
1525 self
.assertDictEqual(new_port_result
, new_port
)
1526 self
.assertDictEqual(port_result
, expected_port
)
1528 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1529 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1530 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1531 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1532 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1534 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1535 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1536 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1537 @patch.object(vimconnector
, "_create_new_port")
1538 @patch.object(vimconnector
, "_set_fixed_ip")
1539 def test_create_port_nova_api_version_smaller_than_232(
1542 mock_create_new_port
,
1543 mock_prepare_port_dict_mac_ip_addr
,
1544 mock_prepare_port_dict_binding
,
1545 mock_prepare_port_dict_security_groups
,
1547 """Nova api version is smaller than 2.32."""
1548 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.30"
1557 "mac_address": mac_address
,
1559 "fixed_ips": [{"ip_address": ip_addr1
}],
1562 mock_create_new_port
.return_value
= new_port
1567 "network_id": net_id
,
1568 "admin_state_up": True,
1572 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1573 net
, name
, created_items
1576 self
.assertDictEqual(new_port_result
, new_port
)
1577 self
.assertDictEqual(port_result
, expected_port
)
1579 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1580 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1581 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1582 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1583 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1585 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1586 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1587 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1588 @patch.object(vimconnector
, "_create_new_port")
1589 @patch.object(vimconnector
, "_set_fixed_ip")
1590 def test_create_port_create_new_port_raise_exception(
1593 mock_create_new_port
,
1594 mock_prepare_port_dict_mac_ip_addr
,
1595 mock_prepare_port_dict_binding
,
1596 mock_prepare_port_dict_security_groups
,
1598 """_create_new_port method raises exception."""
1604 mock_create_new_port
.side_effect
= Exception
1606 "network_id": net_id
,
1607 "admin_state_up": True,
1611 with self
.assertRaises(Exception):
1612 self
.vimconn
._create
_port
(net
, name
, created_items
)
1614 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1615 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1616 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1617 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1618 mock_set_fixed_ip
.assert_not_called()
1620 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1621 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1622 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1623 @patch.object(vimconnector
, "_create_new_port")
1624 @patch.object(vimconnector
, "_set_fixed_ip")
1625 def test_create_port_create_sec_groups_raises_exception(
1628 mock_create_new_port
,
1629 mock_prepare_port_dict_mac_ip_addr
,
1630 mock_prepare_port_dict_binding
,
1631 mock_prepare_port_dict_security_groups
,
1633 """_prepare_port_dict_security_groups method raises exception."""
1639 mock_prepare_port_dict_security_groups
.side_effect
= Exception
1641 "network_id": net_id
,
1642 "admin_state_up": True,
1646 with self
.assertRaises(Exception):
1647 self
.vimconn
._create
_port
(net
, name
, created_items
)
1649 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1651 mock_prepare_port_dict_binding
.assert_not_called()
1652 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
1653 mock_create_new_port
.assert_not_called()
1654 mock_set_fixed_ip
.assert_not_called()
1656 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1657 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1658 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1659 @patch.object(vimconnector
, "_create_new_port")
1660 @patch.object(vimconnector
, "_set_fixed_ip")
1661 def test_create_port_create_port_dict_binding_raise_exception(
1664 mock_create_new_port
,
1665 mock_prepare_port_dict_mac_ip_addr
,
1666 mock_prepare_port_dict_binding
,
1667 mock_prepare_port_dict_security_groups
,
1669 """_prepare_port_dict_binding method raises exception."""
1676 mock_prepare_port_dict_binding
.side_effect
= Exception
1678 "network_id": net_id
,
1679 "admin_state_up": True,
1683 with self
.assertRaises(Exception):
1684 self
.vimconn
._create
_port
(net
, name
, created_items
)
1686 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1688 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1690 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
1691 mock_create_new_port
.assert_not_called()
1692 mock_set_fixed_ip
.assert_not_called()
1694 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1695 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1696 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1697 @patch.object(vimconnector
, "_create_new_port")
1698 @patch.object(vimconnector
, "_set_fixed_ip")
1699 def test_create_port_create_port_mac_ip_addr_raise_exception(
1702 mock_create_new_port
,
1703 mock_prepare_port_dict_mac_ip_addr
,
1704 mock_prepare_port_dict_binding
,
1705 mock_prepare_port_dict_security_groups
,
1707 """prepare_port_dict_mac_ip_addr method raises exception."""
1713 mock_prepare_port_dict_mac_ip_addr
.side_effect
= Exception
1715 "network_id": net_id
,
1716 "admin_state_up": True,
1720 with self
.assertRaises(Exception):
1721 self
.vimconn
._create
_port
(net
, name
, created_items
)
1723 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1724 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1725 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1727 mock_create_new_port
.assert_not_called()
1728 mock_set_fixed_ip
.assert_not_called()
1730 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1731 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1732 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1733 @patch.object(vimconnector
, "_create_new_port")
1734 @patch.object(vimconnector
, "_set_fixed_ip")
1735 def test_create_port_create_port_set_fixed_ip_raise_exception(
1738 mock_create_new_port
,
1739 mock_prepare_port_dict_mac_ip_addr
,
1740 mock_prepare_port_dict_binding
,
1741 mock_prepare_port_dict_security_groups
,
1743 """_set_fixed_ip method raises exception."""
1749 mock_set_fixed_ip
.side_effect
= VimConnException(
1750 "Port detail is missing in new_port."
1753 "network_id": net_id
,
1754 "admin_state_up": True,
1760 "mac_address": mac_address
,
1762 "fixed_ips": [{"ip_address": ip_addr1
}],
1765 mock_create_new_port
.return_value
= new_port
1767 with self
.assertRaises(VimConnException
):
1768 self
.vimconn
._create
_port
(net
, name
, created_items
)
1770 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1771 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1772 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1773 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1774 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1776 @patch.object(vimconnector
, "_reload_connection")
1777 @patch.object(vimconnector
, "_create_port")
1778 def test_prepare_network_for_vm_instance_no_net_id(
1779 self
, mock_create_port
, mock_reload_connection
1781 """Nets do not have net_id"""
1782 mock_reload_connection
.side_effect
= None
1787 "port_security": False,
1788 "exit_on_floating_ip_error": False,
1789 "port_security_disable_strategy": "full",
1792 "port_security": True,
1793 "exit_on_floating_ip_error": False,
1794 "floating_ip": True,
1798 external_network
, no_secured_ports
= [], []
1799 expected_external_network
, expected_no_secured_ports
= [], []
1800 expected_net_list_vim
= []
1802 self
.vimconn
._prepare
_network
_for
_vminstance
(
1810 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1811 self
.assertEqual(external_network
, expected_external_network
)
1812 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1814 mock_create_port
.assert_not_called()
1816 @patch.object(vimconnector
, "_reload_connection")
1817 @patch.object(vimconnector
, "_create_port")
1818 def test_prepare_network_for_vm_instance_empty_net_list(
1819 self
, mock_create_port
, mock_reload_connection
1821 """Net list is empty."""
1822 mock_reload_connection
.side_effect
= None
1825 external_network
, no_secured_ports
= [], []
1826 expected_external_network
, expected_no_secured_ports
= [], []
1827 expected_net_list_vim
= []
1829 self
.vimconn
._prepare
_network
_for
_vminstance
(
1837 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1838 self
.assertEqual(external_network
, expected_external_network
)
1839 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1841 mock_create_port
.assert_not_called()
1843 @patch.object(vimconnector
, "_reload_connection")
1844 @patch.object(vimconnector
, "_create_port")
1845 def test_prepare_network_for_vm_instance_use_floating_ip_false_mgmt_net(
1846 self
, mock_create_port
, mock_reload_connection
1848 """Nets have net-id, floating_ip False, mgmt network."""
1849 mock_reload_connection
.side_effect
= None
1854 "floating_ip": False,
1859 mock_create_port
.side_effect
= [
1864 "mac_address": mac_address
,
1868 {"port-dict": port2_id
},
1871 external_network
, no_secured_ports
= [], []
1872 expected_external_network
, expected_no_secured_ports
= [], []
1873 expected_net_list_vim
= [{"port-dict": port2_id
}]
1874 self
.vimconn
._prepare
_network
_for
_vminstance
(
1882 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1883 self
.assertEqual(external_network
, expected_external_network
)
1884 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1886 mock_create_port
.assert_called_once_with(
1889 "floating_ip": False,
1896 @patch.object(vimconnector
, "_reload_connection")
1897 def test_prepare_network_for_vm_instance_mgmt_net_net_port_security_and_floating_ip_true(
1898 self
, mock_reload_connection
1900 """Nets have net-id, use_floating_ip False in VIM config, mgmt network, net floating_ip is True."""
1901 self
.vimconn
.config
["use_floating_ip"] = False
1902 mock_create_port
= CopyingMock()
1903 mock_reload_connection
.side_effect
= None
1908 "floating_ip": True,
1913 mock_create_port
.side_effect
= [
1918 "mac_address": mac_address
,
1922 {"port-dict": port2_id
},
1925 external_network
, no_secured_ports
= [], []
1926 expected_external_network
= [
1929 "floating_ip": True,
1931 "exit_on_floating_ip_error": True,
1934 expected_no_secured_ports
= []
1935 expected_net_list_vim
= [{"port-dict": port2_id
}]
1936 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1937 self
.vimconn
._prepare
_network
_for
_vminstance
(
1945 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1946 self
.assertEqual(external_network
, expected_external_network
)
1947 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1949 mock_create_port
.assert_called_once_with(
1952 "floating_ip": True,
1959 @patch.object(vimconnector
, "_reload_connection")
1960 def test_prepare_network_for_vm_instance_use_floating_ip_true_mgmt_net_port_security_false(
1961 self
, mock_reload_connection
1963 """Nets have net-id, use_floating_ip is True in VIM config, mgmt network, net port security is False."""
1964 mock_create_port
= CopyingMock()
1965 self
.vimconn
.config
["use_floating_ip"] = True
1966 self
.vimconn
.config
["no_port_security_extension"] = False
1967 mock_reload_connection
.side_effect
= None
1974 "port_security": False,
1975 "exit_on_floating_ip_error": False,
1976 "port_security_disable_strategy": "full",
1980 mock_create_port
.side_effect
= [
1985 "mac_address": mac_address
,
1989 {"port-dict": port2_id
},
1992 external_network
, no_secured_ports
= [], []
1993 expected_external_network
= [
1997 "port_security": False,
1998 "exit_on_floating_ip_error": False,
1999 "port_security_disable_strategy": "full",
2000 "floating_ip": True,
2003 expected_no_secured_ports
= [(port2_id
, "full")]
2004 expected_net_list_vim
= [{"port-dict": port2_id
}]
2005 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2006 self
.vimconn
._prepare
_network
_for
_vminstance
(
2015 mock_create_port
.assert_called_once_with(
2019 "port_security": False,
2020 "exit_on_floating_ip_error": False,
2021 "port_security_disable_strategy": "full",
2026 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2027 self
.assertEqual(external_network
, expected_external_network
)
2028 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2030 @patch.object(vimconnector
, "_reload_connection")
2031 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_false(
2032 self
, mock_reload_connection
2034 """Nets have net-id, use_floating_ip True in VIM config, non-mgmt network, port security is False."""
2035 mock_create_port
= CopyingMock()
2036 self
.vimconn
.config
["use_floating_ip"] = True
2037 self
.vimconn
.config
["no_port_security_extension"] = False
2038 mock_reload_connection
.side_effect
= None
2045 "port_security": False,
2046 "port_security_disable_strategy": "full",
2050 mock_create_port
.side_effect
= [
2055 "mac_address": mac_address
,
2059 {"port-dict": port2_id
},
2062 external_network
, no_secured_ports
= [], []
2063 expected_external_network
= []
2064 expected_no_secured_ports
= [(port2_id
, "full")]
2065 expected_net_list_vim
= [{"port-dict": port2_id
}]
2066 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2067 self
.vimconn
._prepare
_network
_for
_vminstance
(
2076 mock_create_port
.assert_called_once_with(
2080 "port_security": False,
2081 "port_security_disable_strategy": "full",
2086 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2087 self
.assertEqual(external_network
, expected_external_network
)
2088 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2090 @patch.object(vimconnector
, "_reload_connection")
2091 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_true(
2092 self
, mock_reload_connection
2094 """Nets have net-id, use_floating_ip is True in VIM config, non-mgmt network, net port security is True."""
2095 mock_create_port
= CopyingMock()
2096 self
.vimconn
.config
["use_floating_ip"] = True
2097 self
.vimconn
.config
["no_port_security_extension"] = True
2098 mock_reload_connection
.side_effect
= None
2105 "port_security": True,
2106 "port_security_disable_strategy": "full",
2110 mock_create_port
.side_effect
= [
2115 "mac_address": mac_address
,
2119 {"port-dict": port2_id
},
2122 external_network
, no_secured_ports
= [], []
2123 expected_external_network
= []
2124 expected_no_secured_ports
= []
2125 expected_net_list_vim
= [{"port-dict": port2_id
}]
2126 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2127 self
.vimconn
._prepare
_network
_for
_vminstance
(
2136 mock_create_port
.assert_called_once_with(
2140 "port_security": True,
2141 "port_security_disable_strategy": "full",
2146 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2147 self
.assertEqual(external_network
, expected_external_network
)
2148 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2150 @patch.object(vimconnector
, "_reload_connection")
2151 def test_prepare_network_for_vm_instance_create_port_raise_exception(
2152 self
, mock_reload_connection
2154 """_create_port method raise exception."""
2155 mock_create_port
= CopyingMock()
2156 self
.vimconn
.config
["use_floating_ip"] = True
2157 self
.vimconn
.config
["no_port_security_extension"] = True
2158 mock_reload_connection
.side_effect
= None
2165 "port_security": True,
2166 "port_security_disable_strategy": "full",
2170 mock_create_port
.side_effect
= KeyError
2171 external_network
, no_secured_ports
= [], []
2172 expected_external_network
= []
2173 expected_no_secured_ports
= []
2174 expected_net_list_vim
= []
2175 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2176 with self
.assertRaises(Exception) as err
:
2177 self
.vimconn
._prepare
_network
_for
_vminstance
(
2186 self
.assertEqual(type(err
.exception
), KeyError)
2188 mock_create_port
.assert_called_once_with(
2192 "port_security": True,
2193 "port_security_disable_strategy": "full",
2198 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2199 self
.assertEqual(external_network
, expected_external_network
)
2200 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2202 @patch.object(vimconnector
, "_reload_connection")
2203 def test_prepare_network_for_vm_instance_reload_connection_raise_exception(
2204 self
, mock_reload_connection
2206 """_reload_connection method raises exception."""
2207 mock_create_port
= CopyingMock()
2208 mock_reload_connection
.side_effect
= VimConnConnectionException(
2209 "Connection failed."
2211 self
.vimconn
.config
["use_floating_ip"] = True
2212 self
.vimconn
.config
["no_port_security_extension"] = True
2219 "port_security": True,
2220 "port_security_disable_strategy": "full",
2224 mock_create_port
.side_effect
= None
2225 external_network
, no_secured_ports
= [], []
2226 expected_external_network
= []
2227 expected_no_secured_ports
= []
2228 expected_net_list_vim
= []
2229 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2230 with self
.assertRaises(Exception) as err
:
2231 self
.vimconn
._prepare
_network
_for
_vminstance
(
2240 self
.assertEqual(type(err
.exception
), VimConnConnectionException
)
2241 self
.assertEqual(str(err
.exception
), "Connection failed.")
2242 mock_reload_connection
.assert_called_once()
2243 mock_create_port
.assert_not_called()
2244 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2245 self
.assertEqual(external_network
, expected_external_network
)
2246 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2248 def test_prepare_persistent_root_volumes_vim_using_volume_id(self
):
2249 """Existing persistent root volume with vim_volume_id."""
2250 vm_av_zone
= ["nova"]
2251 base_disk_index
= ord("a")
2252 disk
= {"vim_volume_id": volume_id
}
2253 block_device_mapping
= {}
2254 existing_vim_volumes
= []
2256 expected_boot_vol_id
= None
2257 expected_block_device_mapping
= {"vda": volume_id
}
2258 expected_existing_vim_volumes
= [{"id": volume_id
}]
2259 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2264 block_device_mapping
,
2265 existing_vim_volumes
,
2268 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2269 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2270 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2271 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2273 def test_prepare_persistent_non_root_volumes_vim_using_volume_id(self
):
2274 """Existing persistent non root volume with vim_volume_id."""
2275 vm_av_zone
= ["nova"]
2276 base_disk_index
= ord("b")
2277 disk
= {"vim_volume_id": volume_id
}
2278 block_device_mapping
= {}
2279 existing_vim_volumes
= []
2281 expected_block_device_mapping
= {"vdb": volume_id
}
2282 expected_existing_vim_volumes
= [{"id": volume_id
}]
2283 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2287 block_device_mapping
,
2289 existing_vim_volumes
,
2292 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2293 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2294 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2296 def test_prepare_persistent_root_volumes_using_vim_id(self
):
2297 """Existing persistent root volume with vim_id."""
2298 vm_av_zone
= ["nova"]
2299 base_disk_index
= ord("a")
2300 disk
= {"vim_id": volume_id
}
2301 block_device_mapping
= {}
2302 existing_vim_volumes
= []
2304 expected_boot_vol_id
= None
2305 expected_block_device_mapping
= {"vda": volume_id
}
2306 expected_existing_vim_volumes
= [{"id": volume_id
}]
2307 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2312 block_device_mapping
,
2313 existing_vim_volumes
,
2316 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2317 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2318 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2319 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2321 def test_prepare_persistent_non_root_volumes_using_vim_id(self
):
2322 """Existing persistent root volume with vim_id."""
2323 vm_av_zone
= ["nova"]
2324 base_disk_index
= ord("b")
2325 disk
= {"vim_id": volume_id
}
2326 block_device_mapping
= {}
2327 existing_vim_volumes
= []
2330 expected_block_device_mapping
= {"vdb": volume_id
}
2331 expected_existing_vim_volumes
= [{"id": volume_id
}]
2332 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2336 block_device_mapping
,
2338 existing_vim_volumes
,
2342 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2343 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2344 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2346 def test_prepare_persistent_root_volumes_create(self
):
2347 """Create persistent root volume."""
2348 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
2349 vm_av_zone
= ["nova"]
2350 base_disk_index
= ord("a")
2351 disk
= {"size": 10, "image_id": image_id
}
2352 block_device_mapping
= {}
2353 existing_vim_volumes
= []
2355 expected_boot_vol_id
= volume_id2
2356 expected_block_device_mapping
= {"vda": volume_id2
}
2357 expected_existing_vim_volumes
= []
2358 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2363 block_device_mapping
,
2364 existing_vim_volumes
,
2367 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2368 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2369 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2370 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2374 availability_zone
=["nova"],
2376 self
.assertEqual(created_items
, {f
"volume:{volume_id2}": True})
2378 def test_prepare_persistent_non_root_volumes_create(self
):
2379 """Create persistent non-root volume."""
2380 self
.vimconn
.cinder
= CopyingMock()
2381 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
2382 vm_av_zone
= ["nova"]
2383 base_disk_index
= ord("a")
2385 block_device_mapping
= {}
2386 existing_vim_volumes
= []
2388 expected_block_device_mapping
= {"vda": volume_id2
}
2389 expected_existing_vim_volumes
= []
2390 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2394 block_device_mapping
,
2396 existing_vim_volumes
,
2400 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2401 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2402 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2403 size
=10, name
="basicvmvda", availability_zone
=["nova"]
2405 self
.assertEqual(created_items
, {f
"volume:{volume_id2}": True})
2407 def test_prepare_persistent_root_volumes_create_raise_exception(self
):
2408 """Create persistent root volume raise exception."""
2409 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
2410 vm_av_zone
= ["nova"]
2411 base_disk_index
= ord("a")
2412 disk
= {"size": 10, "image_id": image_id
}
2413 block_device_mapping
= {}
2414 existing_vim_volumes
= []
2417 with self
.assertRaises(Exception):
2418 result
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2423 block_device_mapping
,
2424 existing_vim_volumes
,
2428 self
.assertEqual(result
, None)
2430 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2434 availability_zone
=["nova"],
2436 self
.assertEqual(existing_vim_volumes
, [])
2437 self
.assertEqual(block_device_mapping
, {})
2438 self
.assertEqual(created_items
, {})
2440 def test_prepare_persistent_non_root_volumes_create_raise_exception(self
):
2441 """Create persistent non-root volume raise exception."""
2442 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
2443 vm_av_zone
= ["nova"]
2444 base_disk_index
= ord("b")
2446 block_device_mapping
= {}
2447 existing_vim_volumes
= []
2450 with self
.assertRaises(Exception):
2451 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2455 block_device_mapping
,
2457 existing_vim_volumes
,
2461 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2462 size
=10, name
="basicvmvdb", availability_zone
=["nova"]
2464 self
.assertEqual(existing_vim_volumes
, [])
2465 self
.assertEqual(block_device_mapping
, {})
2466 self
.assertEqual(created_items
, {})
2468 @patch("time.sleep")
2469 def test_wait_for_created_volumes_availability_volume_status_available(
2472 """Created volume status is available."""
2474 created_items
= {f
"volume:{volume_id2}": True}
2475 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
2477 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2478 elapsed_time
, created_items
2480 self
.assertEqual(result
, elapsed_time
)
2481 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2482 mock_sleep
.assert_not_called()
2484 @patch("time.sleep")
2485 def test_wait_for_existing_volumes_availability_volume_status_available(
2488 """Existing volume status is available."""
2490 existing_vim_volumes
= [{"id": volume_id2
}]
2491 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
2493 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2494 elapsed_time
, existing_vim_volumes
2496 self
.assertEqual(result
, elapsed_time
)
2497 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2498 mock_sleep
.assert_not_called()
2500 @patch("time.sleep")
2501 def test_wait_for_created_volumes_availability_status_processing_multiple_volumes(
2504 """Created volume status is processing."""
2507 f
"volume:{volume_id2}": True,
2508 f
"volume:{volume_id3}": True,
2510 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2511 Status("processing"),
2512 Status("available"),
2513 Status("available"),
2516 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2517 elapsed_time
, created_items
2519 self
.assertEqual(result
, 10)
2520 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
2521 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
2522 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
2523 self
.assertEqual(_call_mock_get_volumes
[2][0], (volume_id3
,))
2524 mock_sleep
.assert_called_with(5)
2525 self
.assertEqual(1, mock_sleep
.call_count
)
2527 @patch("time.sleep")
2528 def test_wait_for_existing_volumes_availability_status_processing_multiple_volumes(
2531 """Existing volume status is processing."""
2533 existing_vim_volumes
= [
2535 {"id": "44e0e83-b9uu-4akk-t234-p9cc4811bd4a"},
2537 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2538 Status("processing"),
2539 Status("available"),
2540 Status("available"),
2543 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2544 elapsed_time
, existing_vim_volumes
2546 self
.assertEqual(result
, 10)
2547 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
2548 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
2549 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
2551 _call_mock_get_volumes
[2][0], ("44e0e83-b9uu-4akk-t234-p9cc4811bd4a",)
2553 mock_sleep
.assert_called_with(5)
2554 self
.assertEqual(1, mock_sleep
.call_count
)
2556 @patch("time.sleep")
2557 def test_wait_for_created_volumes_availability_volume_status_processing_timeout(
2560 """Created volume status is processing, elapsed time greater than timeout (1800)."""
2562 created_items
= {f
"volume:{volume_id2}": True}
2563 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2564 Status("processing"),
2565 Status("processing"),
2567 with
patch("time.sleep", mock_sleep
):
2568 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2569 elapsed_time
, created_items
2571 self
.assertEqual(result
, 1805)
2572 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2573 mock_sleep
.assert_not_called()
2575 @patch("time.sleep")
2576 def test_wait_for_existing_volumes_availability_volume_status_processing_timeout(
2579 """Exsiting volume status is processing, elapsed time greater than timeout (1800)."""
2581 existing_vim_volumes
= [{"id": volume_id2
}]
2582 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2583 Status("processing"),
2584 Status("processing"),
2587 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2588 elapsed_time
, existing_vim_volumes
2590 self
.assertEqual(result
, 1805)
2591 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2592 mock_sleep
.assert_not_called()
2594 @patch("time.sleep")
2595 def test_wait_for_created_volumes_availability_cinder_raise_exception(
2598 """Cinder get volumes raises exception for created volumes."""
2600 created_items
= {f
"volume:{volume_id2}": True}
2601 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
2602 with self
.assertRaises(Exception):
2603 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2604 elapsed_time
, created_items
2606 self
.assertEqual(result
, 1000)
2607 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2608 mock_sleep
.assert_not_called()
2610 @patch("time.sleep")
2611 def test_wait_for_existing_volumes_availability_cinder_raise_exception(
2614 """Cinder get volumes raises exception for existing volumes."""
2616 existing_vim_volumes
= [{"id": volume_id2
}]
2617 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
2618 with self
.assertRaises(Exception):
2619 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2620 elapsed_time
, existing_vim_volumes
2622 self
.assertEqual(result
, 1000)
2623 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2624 mock_sleep
.assert_not_called()
2626 @patch("time.sleep")
2627 def test_wait_for_created_volumes_availability_no_volume_in_created_items(
2630 """Created_items dict does not have volume-id."""
2634 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
2636 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2637 elapsed_time
, created_items
2639 self
.assertEqual(result
, 10)
2640 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2641 mock_sleep
.assert_not_called()
2643 @patch("time.sleep")
2644 def test_wait_for_existing_volumes_availability_no_volume_in_existing_vim_volumes(
2647 """Existing_vim_volumes list does not have volume."""
2649 existing_vim_volumes
= []
2651 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
2653 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2654 elapsed_time
, existing_vim_volumes
2656 self
.assertEqual(result
, 10)
2657 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2658 mock_sleep
.assert_not_called()
2660 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2661 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2662 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2663 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2664 def test_prepare_disk_for_vm_instance(
2666 mock_existing_vol_availability
,
2667 mock_created_vol_availability
,
2668 mock_non_root_volumes
,
2671 """Prepare disks for VM instance successfully."""
2672 existing_vim_volumes
= []
2674 vm_av_zone
= ["nova"]
2676 mock_root_volumes
.return_value
= root_vol_id
2677 mock_created_vol_availability
.return_value
= 10
2678 mock_existing_vol_availability
.return_value
= 15
2679 self
.vimconn
.cinder
= CopyingMock()
2681 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2682 name
, existing_vim_volumes
, created_items
, vm_av_zone
, disk_list2
2684 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_called_once_with(
2687 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2688 mock_existing_vol_availability
.assert_called_once_with(10, existing_vim_volumes
)
2689 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2690 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2691 mock_root_volumes
.assert_called_once_with(
2693 vm_av_zone
=["nova"],
2694 disk
={"size": 10, "image_id": image_id
},
2696 block_device_mapping
={},
2697 existing_vim_volumes
=[],
2700 mock_non_root_volumes
.assert_called_once_with(
2703 vm_av_zone
=["nova"],
2705 block_device_mapping
={},
2706 existing_vim_volumes
=[],
2710 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2711 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2712 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2713 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2714 def test_prepare_disk_for_vm_instance_timeout_exceeded(
2716 mock_existing_vol_availability
,
2717 mock_created_vol_availability
,
2718 mock_non_root_volumes
,
2721 """Timeout exceeded while waiting for disks."""
2722 existing_vim_volumes
= []
2724 vm_av_zone
= ["nova"]
2726 mock_root_volumes
.return_value
= root_vol_id
2727 mock_created_vol_availability
.return_value
= 1700
2728 mock_existing_vol_availability
.return_value
= 1900
2730 with self
.assertRaises(VimConnException
) as err
:
2731 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2732 name
, existing_vim_volumes
, created_items
, vm_av_zone
, disk_list2
2735 str(err
.exception
), "Timeout creating volumes for instance basicvm"
2737 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2738 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2739 mock_existing_vol_availability
.assert_called_once_with(
2740 1700, existing_vim_volumes
2742 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2743 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2744 mock_root_volumes
.assert_called_once_with(
2746 vm_av_zone
=["nova"],
2747 disk
={"size": 10, "image_id": image_id
},
2749 block_device_mapping
={},
2750 existing_vim_volumes
=[],
2753 mock_non_root_volumes
.assert_called_once_with(
2756 vm_av_zone
=["nova"],
2758 block_device_mapping
={},
2759 existing_vim_volumes
=[],
2763 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2764 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2765 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2766 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2767 def test_prepare_disk_for_vm_instance_empty_disk_list(
2769 mock_existing_vol_availability
,
2770 mock_created_vol_availability
,
2771 mock_non_root_volumes
,
2774 """Disk list is empty."""
2775 existing_vim_volumes
= []
2777 vm_av_zone
= ["nova"]
2778 mock_created_vol_availability
.return_value
= 2
2779 mock_existing_vol_availability
.return_value
= 3
2781 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2782 name
, existing_vim_volumes
, created_items
, vm_av_zone
, disk_list
2784 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2785 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2786 mock_existing_vol_availability
.assert_called_once_with(2, existing_vim_volumes
)
2787 mock_root_volumes
.assert_not_called()
2788 mock_non_root_volumes
.assert_not_called()
2790 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2791 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2792 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2793 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2794 def test_prepare_disk_for_vm_instance_persistent_root_volume_error(
2796 mock_existing_vol_availability
,
2797 mock_created_vol_availability
,
2798 mock_non_root_volumes
,
2801 """Persistent root volumes preparation raises error."""
2802 existing_vim_volumes
= []
2804 vm_av_zone
= ["nova"]
2806 mock_root_volumes
.side_effect
= Exception()
2807 mock_created_vol_availability
.return_value
= 10
2808 mock_existing_vol_availability
.return_value
= 15
2810 with self
.assertRaises(Exception):
2811 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2812 name
, existing_vim_volumes
, created_items
, vm_av_zone
, disk_list2
2814 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2815 mock_created_vol_availability
.assert_not_called()
2816 mock_existing_vol_availability
.assert_not_called()
2817 mock_root_volumes
.assert_called_once_with(
2819 vm_av_zone
=["nova"],
2820 disk
={"size": 10, "image_id": image_id
},
2822 block_device_mapping
={},
2823 existing_vim_volumes
=[],
2826 mock_non_root_volumes
.assert_not_called()
2828 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2829 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2830 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2831 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2832 def test_prepare_disk_for_vm_instance_non_root_volume_error(
2834 mock_existing_vol_availability
,
2835 mock_created_vol_availability
,
2836 mock_non_root_volumes
,
2839 """Non-root volumes preparation raises error."""
2840 existing_vim_volumes
= []
2842 vm_av_zone
= ["nova"]
2844 mock_root_volumes
.return_value
= root_vol_id
2845 mock_non_root_volumes
.side_effect
= Exception
2847 with self
.assertRaises(Exception):
2848 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2849 name
, existing_vim_volumes
, created_items
, vm_av_zone
, disk_list2
2851 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2852 mock_created_vol_availability
.assert_not_called()
2853 mock_existing_vol_availability
.assert_not_called()
2854 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2855 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2856 mock_root_volumes
.assert_called_once_with(
2858 vm_av_zone
=["nova"],
2859 disk
={"size": 10, "image_id": image_id
},
2861 block_device_mapping
={},
2862 existing_vim_volumes
=[],
2865 mock_non_root_volumes
.assert_called_once_with(
2868 vm_av_zone
=["nova"],
2870 block_device_mapping
={},
2871 existing_vim_volumes
=[],
2875 def test_find_external_network_for_floating_ip_no_external_network(self
):
2876 """External network could not be found."""
2877 self
.vimconn
.neutron
.list_networks
.return_value
= {
2879 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": False}
2882 with self
.assertRaises(VimConnException
) as err
:
2883 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2886 "Cannot create floating_ip automatically since no external network is present",
2889 def test_find_external_network_for_floating_one_external_network(self
):
2890 """One external network has been found."""
2891 self
.vimconn
.neutron
.list_networks
.return_value
= {
2893 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True}
2896 expected_result
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
2897 result
= self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2898 self
.assertEqual(result
, expected_result
)
2900 def test_find_external_network_for_floating_neutron_raises_exception(self
):
2901 """Neutron list networks raises exception."""
2902 self
.vimconn
.neutron
.list_networks
.side_effect
= Exception
2903 with self
.assertRaises(Exception):
2904 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2906 def test_find_external_network_for_floating_several_external_network(self
):
2907 """Several exernal networks has been found."""
2908 self
.vimconn
.neutron
.list_networks
.return_value
= {
2910 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True},
2911 {"id": "608b73-y9cc-5a6a-a270-12cc4811bd4a", "router:external": True},
2914 with self
.assertRaises(VimConnException
) as err
:
2915 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2918 "Cannot create floating_ip automatically since multiple external networks are present",
2921 def test_neutron_create_float_ip(self
):
2922 """Floating ip creation is successful."""
2923 param
= {"net_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a"}
2925 self
.vimconn
.neutron
.create_floatingip
.return_value
= {
2926 "floatingip": {"id": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2928 expected_created_items
= {
2929 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True
2931 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2932 self
.assertEqual(created_items
, expected_created_items
)
2934 def test_neutron_create_float_ip_exception_occurred(self
):
2935 """Floating ip could not be created."""
2938 "floating_network_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a",
2939 "tenant_id": "308b73-19cc-8a6a-a270-02cc4811bd9a",
2943 self
.vimconn
.neutron
= CopyingMock()
2944 self
.vimconn
.neutron
.create_floatingip
.side_effect
= Exception(
2945 "Neutron floating ip create exception occurred."
2947 with self
.assertRaises(VimConnException
) as err
:
2948 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2949 self
.assertEqual(created_items
, {})
2952 "Exception: Cannot create new floating_ip Neutron floating ip create exception occurred.",
2955 @patch.object(vimconnector
, "_neutron_create_float_ip")
2956 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2957 def test_create_floating_ip_pool_id_available(
2958 self
, mock_find_ext_network
, mock_create_float_ip
2960 """Floating ip creation, ip pool is available."""
2961 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2965 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2966 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2969 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2970 mock_find_ext_network
.assert_not_called()
2971 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2973 @patch.object(vimconnector
, "_neutron_create_float_ip")
2974 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2975 def test_create_floating_ip_finding_pool_id(
2976 self
, mock_find_ext_network
, mock_create_float_ip
2978 """Floating ip creation, pool id need to be found."""
2979 floating_network
= {"floating_ip": True}
2981 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
2984 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
2985 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
2988 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
2989 mock_find_ext_network
.assert_called_once()
2990 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
2992 @patch.object(vimconnector
, "_neutron_create_float_ip")
2993 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2994 def test_create_floating_ip_neutron_create_floating_ip_exception(
2995 self
, mock_find_ext_network
, mock_create_float_ip
2997 """Neutron creat floating ip raises error."""
2998 floating_network
= {"floating_ip": True}
3000 mock_create_float_ip
.side_effect
= VimConnException(
3001 "Can not create floating ip."
3003 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
3006 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3007 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3011 with self
.assertRaises(VimConnException
) as err
:
3012 self
.vimconn
._create
_floating
_ip
(
3013 floating_network
, self
.server
, created_items
3015 self
.assertEqual(str(err
.exception
), "Can not create floating ip.")
3016 mock_find_ext_network
.assert_called_once()
3017 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
3019 @patch.object(vimconnector
, "_neutron_create_float_ip")
3020 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
3021 def test_create_floating_ip_can_not_find_pool_id(
3022 self
, mock_find_ext_network
, mock_create_float_ip
3024 """Floating ip creation, pool id could not be found."""
3025 floating_network
= {"floating_ip": True}
3027 mock_find_ext_network
.side_effect
= VimConnException(
3028 "Cannot create floating_ip automatically since no external network is present"
3030 with self
.assertRaises(VimConnException
) as err
:
3031 self
.vimconn
._create
_floating
_ip
(
3032 floating_network
, self
.server
, created_items
3036 "Cannot create floating_ip automatically since no external network is present",
3038 mock_find_ext_network
.assert_called_once()
3039 mock_create_float_ip
.assert_not_called()
3041 def test_find_floating_ip_get_free_floating_ip(self
):
3042 """Get free floating ips successfully."""
3045 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3046 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3047 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3050 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3051 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3053 result
= self
.vimconn
._find
_floating
_ip
(
3054 self
.server
, floating_ips
, floating_network
3056 self
.assertEqual(result
, expected_result
)
3058 def test_find_floating_ip_different_floating_network_id(self
):
3059 """Floating network id is different with floating_ip of floating network."""
3062 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3063 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3066 floating_network
= {"floating_ip": "508b73-t9cc-1a6a-a270-12cc4811bd4a"}
3068 result
= self
.vimconn
._find
_floating
_ip
(
3069 self
.server
, floating_ips
, floating_network
3071 self
.assertEqual(result
, None)
3073 def test_find_floating_ip_different_fip_tenant(self
):
3074 """Items in floating_ips has port_id, tenant_is is not same with server tenant id."""
3077 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3078 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3079 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3080 "tenant_id": self
.server
.id,
3083 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3084 mock_create_floating_ip
= CopyingMock()
3085 with patch
.object(vimconnector
, "_create_floating_ip", mock_create_floating_ip
):
3086 result
= self
.vimconn
._find
_floating
_ip
(
3087 self
.server
, floating_ips
, floating_network
3089 self
.assertEqual(result
, None)
3091 @patch("time.sleep")
3092 def test_assign_floating_ip(self
, mock_sleep
):
3093 """Assign floating ip successfully."""
3094 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3095 floating_network
= {"vim_id": floating_network_vim_id
}
3097 "port_id": floating_network_vim_id
,
3098 "floating_network_id": "p08b73-e9cc-5a6a-t270-82cc4811bd4a",
3099 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3100 "tenant_id": "k08b73-e9cc-5a6a-t270-82cc4811bd4a",
3102 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
3103 self
.vimconn
.neutron
.show_floatingip
.return_value
= fip
3104 expected_result
= fip
3106 result
= self
.vimconn
._assign
_floating
_ip
(free_floating_ip
, floating_network
)
3107 self
.assertEqual(result
, expected_result
)
3108 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3110 {"floatingip": {"port_id": floating_network_vim_id
}},
3112 mock_sleep
.assert_called_once_with(5)
3113 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
3115 @patch("time.sleep")
3116 def test_assign_floating_ip_update_floating_ip_exception(self
, mock_sleep
):
3117 """Neutron update floating ip raises exception."""
3118 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3119 floating_network
= {"vim_id": floating_network_vim_id
}
3120 self
.vimconn
.neutron
= CopyingMock()
3121 self
.vimconn
.neutron
.update_floatingip
.side_effect
= Exception(
3122 "Floating ip is not updated."
3125 with self
.assertRaises(Exception) as err
:
3126 result
= self
.vimconn
._assign
_floating
_ip
(
3127 free_floating_ip
, floating_network
3129 self
.assertEqual(result
, None)
3130 self
.assertEqual(str(err
.exception
), "Floating ip is not updated.")
3132 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3134 {"floatingip": {"port_id": floating_network_vim_id
}},
3136 mock_sleep
.assert_not_called()
3137 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3139 @patch("time.sleep")
3140 def test_assign_floating_ip_show_floating_ip_exception(self
, mock_sleep
):
3141 """Neutron show floating ip raises exception."""
3142 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3143 floating_network
= {"vim_id": floating_network_vim_id
}
3144 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
3145 self
.vimconn
.neutron
.show_floatingip
.side_effect
= Exception(
3146 "Floating ip could not be shown."
3149 with self
.assertRaises(Exception) as err
:
3150 result
= self
.vimconn
._assign
_floating
_ip
(
3151 free_floating_ip
, floating_network
3153 self
.assertEqual(result
, None)
3154 self
.assertEqual(str(err
.exception
), "Floating ip could not be shown.")
3155 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3157 {"floatingip": {"port_id": floating_network_vim_id
}},
3159 mock_sleep
.assert_called_once_with(5)
3160 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
3162 @patch("random.shuffle")
3163 @patch.object(vimconnector
, "_find_floating_ip")
3164 def test_get_free_floating_ip(self
, mock_find_floating_ip
, mock_shuffle
):
3165 """Get free floating ip successfully."""
3166 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3169 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3170 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3171 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3172 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3175 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3176 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3177 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3178 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3181 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
3182 "floatingips": floating_ips
3184 mock_find_floating_ip
.return_value
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3185 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3187 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3188 self
.assertEqual(result
, expected_result
)
3189 mock_shuffle
.assert_called_once_with(floating_ips
)
3190 mock_find_floating_ip
.assert_called_once_with(
3191 self
.server
, floating_ips
, floating_network
3194 @patch("random.shuffle")
3195 @patch.object(vimconnector
, "_find_floating_ip")
3196 def test_get_free_floating_ip_list_floating_ip_exception(
3197 self
, mock_find_floating_ip
, mock_shuffle
3199 """Neutron list floating IPs raises exception."""
3200 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3201 self
.vimconn
.neutron
= CopyingMock()
3202 self
.vimconn
.neutron
.list_floatingips
.side_effect
= Exception(
3203 "Floating ips could not be listed."
3205 with self
.assertRaises(Exception) as err
:
3206 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3207 self
.assertEqual(result
, None)
3208 self
.assertEqual(str(err
.exception
), "Floating ips could not be listed.")
3209 mock_shuffle
.assert_not_called()
3210 mock_find_floating_ip
.assert_not_called()
3212 @patch("random.shuffle")
3213 @patch.object(vimconnector
, "_find_floating_ip")
3214 def test_get_free_floating_ip_find_floating_ip_exception(
3215 self
, mock_find_floating_ip
, mock_shuffle
3217 """_find_floating_ip method raises exception."""
3218 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3221 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3222 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3223 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3224 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3227 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3228 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3229 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3230 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3233 self
.vimconn
.neutron
= CopyingMock()
3234 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
3235 "floatingips": floating_ips
3237 mock_find_floating_ip
.side_effect
= Exception(
3238 "Free floating ip could not be found."
3241 with self
.assertRaises(Exception) as err
:
3242 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3243 self
.assertEqual(result
, None)
3244 self
.assertEqual(str(err
.exception
), "Free floating ip could not be found.")
3245 mock_shuffle
.assert_called_once_with(floating_ips
)
3246 mock_find_floating_ip
.assert_called_once_with(
3247 self
.server
, floating_ips
, floating_network
3250 @patch.object(vimconnector
, "_create_floating_ip")
3251 @patch.object(vimconnector
, "_get_free_floating_ip")
3252 @patch.object(vimconnector
, "_assign_floating_ip")
3253 def test_prepare_external_network_for_vm_instance(
3255 mock_assign_floating_ip
,
3256 mock_get_free_floating_ip
,
3257 mock_create_floating_ip
,
3259 """Prepare external network successfully."""
3260 external_network
= [
3262 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3263 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3267 vm_start_time
= time_return_value
3268 mock_get_free_floating_ip
.side_effect
= ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
3269 mock_assign_floating_ip
.return_value
= {
3270 "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
3272 self
.vimconn
.neutron
= CopyingMock()
3273 self
.vimconn
.nova
= CopyingMock()
3274 self
.vimconn
.neutron
.show_floatingip
.return_value
= {
3275 "floatingip": {"port_id": ""}
3278 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3279 external_network
, self
.server
, created_items
, vm_start_time
3282 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3283 mock_get_free_floating_ip
.assert_called_once_with(
3286 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3287 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3290 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(
3291 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3293 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3294 mock_create_floating_ip
.assert_not_called()
3295 mock_assign_floating_ip
.assert_called_once_with(
3296 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3298 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3299 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3304 @patch("time.sleep")
3305 @patch.object(vimconnector
, "_create_floating_ip")
3306 @patch.object(vimconnector
, "_get_free_floating_ip")
3307 @patch.object(vimconnector
, "_assign_floating_ip")
3308 def test_prepare_external_network_for_vm_instance_no_free_floating_ip(
3310 mock_assign_floating_ip
,
3311 mock_get_free_floating_ip
,
3312 mock_create_floating_ip
,
3316 """There is not any free floating ip."""
3317 floating_network
= {
3318 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3319 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3321 external_network
= [floating_network
]
3324 vm_start_time
= time_return_value
3325 mock_get_free_floating_ip
.return_value
= None
3326 mock_assign_floating_ip
.return_value
= {}
3327 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3328 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3330 with self
.assertRaises(KeyError):
3331 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3332 external_network
, self
.server
, created_items
, vm_start_time
3335 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3336 mock_get_free_floating_ip
.assert_called_with(
3339 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3340 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3343 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(None)
3344 mock_sleep
.assert_not_called()
3345 mock_time
.assert_not_called()
3346 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3347 mock_create_floating_ip
.assert_called_with(
3348 floating_network
, self
.server
, created_items
3350 self
.assertEqual(mock_create_floating_ip
.call_count
, 4)
3351 mock_assign_floating_ip
.assert_not_called()
3352 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3355 @patch("time.sleep")
3356 @patch.object(vimconnector
, "_create_floating_ip")
3357 @patch.object(vimconnector
, "_get_free_floating_ip")
3358 @patch.object(vimconnector
, "_assign_floating_ip")
3359 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
3361 mock_assign_floating_ip
,
3362 mock_get_free_floating_ip
,
3363 mock_create_floating_ip
,
3367 """There is not any free floating ip, create_floating ip method raise exception
3368 exit_on_floating_ip_error set to False."""
3369 floating_network
= {
3370 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3371 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3372 "exit_on_floating_ip_error": False,
3374 external_network
= [floating_network
]
3377 vm_start_time
= time_return_value
3378 mock_get_free_floating_ip
.return_value
= None
3379 mock_assign_floating_ip
.return_value
= {}
3380 mock_create_floating_ip
.side_effect
= VimConnException(
3381 "Can not create floating ip."
3383 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3384 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3386 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3387 external_network
, self
.server
, created_items
, vm_start_time
3389 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3390 mock_get_free_floating_ip
.assert_called_with(
3393 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3394 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3395 "exit_on_floating_ip_error": False,
3398 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3399 mock_sleep
.assert_not_called()
3400 mock_time
.assert_not_called()
3401 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3402 mock_create_floating_ip
.assert_called_with(
3403 floating_network
, self
.server
, created_items
3405 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
3406 mock_assign_floating_ip
.assert_not_called()
3409 @patch("time.sleep")
3410 @patch.object(vimconnector
, "_create_floating_ip")
3411 @patch.object(vimconnector
, "_get_free_floating_ip")
3412 @patch.object(vimconnector
, "_assign_floating_ip")
3413 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
3415 mock_assign_floating_ip
,
3416 mock_get_free_floating_ip
,
3417 mock_create_floating_ip
,
3421 """There is not any free floating ip, create_floating ip method raise exception
3422 exit_on_floating_ip_error set to False."""
3423 floating_network
= {
3424 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3425 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3426 "exit_on_floating_ip_error": True,
3428 external_network
= [floating_network
]
3431 vm_start_time
= time_return_value
3432 mock_get_free_floating_ip
.return_value
= None
3433 mock_assign_floating_ip
.return_value
= {}
3434 mock_create_floating_ip
.side_effect
= VimConnException(
3435 "Can not create floating ip."
3437 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3438 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3439 with self
.assertRaises(VimConnException
):
3440 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3441 external_network
, self
.server
, created_items
, vm_start_time
3443 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3444 mock_get_free_floating_ip
.assert_called_with(
3447 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3448 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3449 "exit_on_floating_ip_error": True,
3452 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3453 mock_sleep
.assert_not_called()
3454 mock_time
.assert_not_called()
3455 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3456 mock_create_floating_ip
.assert_called_with(
3457 floating_network
, self
.server
, created_items
3459 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
3460 mock_assign_floating_ip
.assert_not_called()
3462 @patch.object(vimconnector
, "_create_floating_ip")
3463 @patch.object(vimconnector
, "_get_free_floating_ip")
3464 @patch.object(vimconnector
, "_assign_floating_ip")
3465 def test_prepare_external_network_for_vm_instance_fip_has_port_id(
3467 mock_assign_floating_ip
,
3468 mock_get_free_floating_ip
,
3469 mock_create_floating_ip
,
3471 """Neutron show floating ip return the fip with port_id and floating network vim_id
3472 is different from port_id."""
3473 floating_network
= {
3474 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3475 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3477 external_network
= [floating_network
]
3480 mock_get_free_floating_ip
.side_effect
= [
3481 "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
3482 "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
3483 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3485 mock_assign_floating_ip
.side_effect
= [
3486 {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3487 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3489 self
.vimconn
.neutron
= CopyingMock()
3490 self
.vimconn
.nova
= CopyingMock()
3491 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3492 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3493 {"floatingip": {"port_id": ""}},
3494 {"floatingip": {"port_id": ""}},
3496 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3497 external_network
, self
.server
, created_items
, vm_start_time
3499 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3500 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3502 _call_mock_get_free_floating_ip
[0][0],
3509 _call_mock_get_free_floating_ip
[1][0],
3516 _call_mock_get_free_floating_ip
[2][0],
3522 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3523 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3524 mock_create_floating_ip
.assert_not_called()
3525 self
.assertEqual(mock_assign_floating_ip
.call_count
, 2)
3526 _call_mock_assign_floating_ip
= mock_assign_floating_ip
.call_args_list
3528 _call_mock_assign_floating_ip
[0][0],
3529 ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
3532 _call_mock_assign_floating_ip
[1][0],
3533 ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
3537 @patch("time.sleep")
3538 @patch.object(vimconnector
, "_create_floating_ip")
3539 @patch.object(vimconnector
, "_get_free_floating_ip")
3540 @patch.object(vimconnector
, "_assign_floating_ip")
3541 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
3543 mock_assign_floating_ip
,
3544 mock_get_free_floating_ip
,
3545 mock_create_floating_ip
,
3549 """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
3550 VM status is in error."""
3551 floating_network
= {
3552 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3553 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3554 "exit_on_floating_ip_error": True,
3556 external_network
= [floating_network
]
3558 vm_start_time
= time_return_value
3560 mock_time
.side_effect
= [156570150, 156570800, 156571200]
3562 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3563 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3564 Exception("Floating ip could not be shown.")
3566 with self
.assertRaises(Exception) as err
:
3567 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3568 external_network
, self
.server
, created_items
, vm_start_time
3572 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3575 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3576 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3578 _call_mock_get_free_floating_ip
[0][0],
3585 _call_mock_get_free_floating_ip
[1][0],
3592 _call_mock_get_free_floating_ip
[2][0],
3599 _call_mock_get_free_floating_ip
[3][0],
3606 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3607 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3608 mock_create_floating_ip
.assert_not_called()
3609 mock_assign_floating_ip
.assert_not_called()
3610 mock_time
.assert_not_called()
3611 mock_sleep
.assert_not_called()
3614 @patch("time.sleep")
3615 @patch.object(vimconnector
, "_create_floating_ip")
3616 @patch.object(vimconnector
, "_get_free_floating_ip")
3617 @patch.object(vimconnector
, "_assign_floating_ip")
3618 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
3620 mock_assign_floating_ip
,
3621 mock_get_free_floating_ip
,
3622 mock_create_floating_ip
,
3626 """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
3627 VM status is in active."""
3628 floating_network
= {
3629 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3630 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3631 "exit_on_floating_ip_error": False,
3633 external_network
= [floating_network
]
3635 vm_start_time
= time_return_value
3637 mock_time
.side_effect
= [156570150, 156570800, 156571200]
3639 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ACTIVE"
3640 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3641 Exception("Floating ip could not be shown.")
3644 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3645 external_network
, self
.server
, created_items
, vm_start_time
3647 # self.assertEqual(str(err.exception), "Cannot create floating_ip")
3649 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3650 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3652 _call_mock_get_free_floating_ip
[0][0],
3659 _call_mock_get_free_floating_ip
[1][0],
3666 _call_mock_get_free_floating_ip
[2][0],
3673 _call_mock_get_free_floating_ip
[3][0],
3680 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3681 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3682 mock_create_floating_ip
.assert_not_called()
3683 mock_assign_floating_ip
.assert_not_called()
3684 mock_time
.assert_not_called()
3685 mock_sleep
.assert_not_called()
3688 @patch("time.sleep")
3689 @patch.object(vimconnector
, "_create_floating_ip")
3690 @patch.object(vimconnector
, "_get_free_floating_ip")
3691 @patch.object(vimconnector
, "_assign_floating_ip")
3692 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
3694 mock_assign_floating_ip
,
3695 mock_get_free_floating_ip
,
3696 mock_create_floating_ip
,
3700 """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
3701 VM status is not ACTIVE or ERROR, server timeout happened."""
3702 floating_network
= {
3703 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3704 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3705 "exit_on_floating_ip_error": True,
3707 external_network
= [floating_network
]
3709 vm_start_time
= time_return_value
3710 mock_get_free_floating_ip
.side_effect
= None
3711 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3712 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "OTHER"
3713 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3714 Exception("Floating ip could not be shown.")
3717 with self
.assertRaises(VimConnException
) as err
:
3718 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3719 external_network
, self
.server
, created_items
, vm_start_time
3723 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3726 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3727 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3729 _call_mock_get_free_floating_ip
[0][0],
3736 _call_mock_get_free_floating_ip
[1][0],
3743 _call_mock_get_free_floating_ip
[2][0],
3750 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3751 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3752 mock_create_floating_ip
.assert_not_called()
3753 mock_assign_floating_ip
.assert_not_called()
3754 self
.assertEqual(mock_time
.call_count
, 3)
3755 self
.assertEqual(mock_sleep
.call_count
, 2)
3758 @patch("time.sleep")
3759 @patch.object(vimconnector
, "_create_floating_ip")
3760 @patch.object(vimconnector
, "_get_free_floating_ip")
3761 @patch.object(vimconnector
, "_assign_floating_ip")
3762 def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3764 mock_assign_floating_ip
,
3765 mock_get_free_floating_ip
,
3766 mock_create_floating_ip
,
3770 """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3771 VM status is in ERROR."""
3772 floating_network
= {
3773 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3774 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3775 "exit_on_floating_ip_error": True,
3777 external_network
= [floating_network
]
3779 vm_start_time
= time_return_value
3781 mock_get_free_floating_ip
.side_effect
= [
3782 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3785 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3787 mock_assign_floating_ip
.side_effect
= [
3788 Exception("Floating ip could not be assigned.")
3791 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3792 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3793 {"floatingip": {"port_id": ""}}
3796 with self
.assertRaises(VimConnException
) as err
:
3797 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3798 external_network
, self
.server
, created_items
, vm_start_time
3802 "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3805 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3806 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3808 _call_mock_get_free_floating_ip
[0][0],
3815 _call_mock_get_free_floating_ip
[1][0],
3822 _call_mock_get_free_floating_ip
[2][0],
3829 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3830 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(
3831 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3833 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3834 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3835 mock_time
.assert_not_called()
3836 mock_sleep
.assert_not_called()
3837 mock_create_floating_ip
.assert_not_called()
3840 @patch("time.sleep")
3841 @patch.object(vimconnector
, "_create_floating_ip")
3842 @patch.object(vimconnector
, "_get_free_floating_ip")
3843 @patch.object(vimconnector
, "_assign_floating_ip")
3844 def test_prepare_external_network_for_vm_instance_empty_external_network_list(
3846 mock_assign_floating_ip
,
3847 mock_get_free_floating_ip
,
3848 mock_create_floating_ip
,
3852 """External network list is empty."""
3853 external_network
= []
3855 vm_start_time
= time_return_value
3857 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3858 external_network
, self
.server
, created_items
, vm_start_time
3860 mock_create_floating_ip
.assert_not_called()
3861 mock_time
.assert_not_called()
3862 mock_sleep
.assert_not_called()
3863 mock_assign_floating_ip
.assert_not_called()
3864 mock_get_free_floating_ip
.assert_not_called()
3865 self
.vimconn
.neutron
.show
.show_floatingip
.assert_not_called()
3866 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3868 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3869 def test_update_port_security_for_vm_instance(self
, mock_wait_for_vm
):
3870 """no_secured_ports has port and the port has allow-address-pairs."""
3871 no_secured_ports
= [(port2_id
, "allow-address-pairs")]
3873 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3875 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3877 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3879 {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
3882 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3883 def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
3884 self
, mock_wait_for_vm
3886 """no_secured_ports has port and the port does not have allow-address-pairs."""
3887 no_secured_ports
= [(port2_id
, "something")]
3889 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3891 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3893 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3895 {"port": {"port_security_enabled": False, "security_groups": None}},
3898 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3899 def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
3900 self
, mock_wait_for_vm
3902 """__wait_for_vm raises timeout exception."""
3903 no_secured_ports
= [(port2_id
, "something")]
3905 mock_wait_for_vm
.side_effect
= VimConnException("Timeout waiting for instance.")
3907 with self
.assertRaises(VimConnException
) as err
:
3908 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3909 no_secured_ports
, self
.server
3911 self
.assertEqual(str(err
.exception
), "Timeout waiting for instance.")
3913 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3915 self
.vimconn
.neutron
.update_port
.assert_not_called()
3917 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3918 def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
3919 self
, mock_wait_for_vm
3921 """neutron_update_port method raises exception."""
3922 no_secured_ports
= [(port2_id
, "something")]
3924 self
.vimconn
.neutron
.update_port
.side_effect
= Exception(
3925 "Port security could not be updated."
3928 with self
.assertRaises(VimConnException
) as err
:
3929 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3930 no_secured_ports
, self
.server
3934 "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
3936 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3938 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3940 {"port": {"port_security_enabled": False, "security_groups": None}},
3943 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3944 def test_update_port_security_for_vm_instance_empty_port_list(
3945 self
, mock_wait_for_vm
3947 """no_secured_ports list does not have any ports."""
3948 no_secured_ports
= []
3950 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3952 mock_wait_for_vm
.assert_not_called()
3954 self
.vimconn
.neutron
.update_port
.assert_not_called()
3957 @patch.object(vimconnector
, "_reload_connection")
3958 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3959 @patch.object(vimconnector
, "_create_user_data")
3960 @patch.object(vimconnector
, "_get_vm_availability_zone")
3961 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3962 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3963 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3964 @patch.object(vimconnector
, "delete_vminstance")
3965 @patch.object(vimconnector
, "_format_exception")
3966 def test_new_vm_instance(
3968 mock_format_exception
,
3969 mock_delete_vm_instance
,
3970 mock_prepare_external_network
,
3971 mock_update_port_security
,
3972 mock_prepare_disk_for_vm_instance
,
3973 mock_get_vm_availability_zone
,
3974 mock_create_user_data
,
3975 mock_prepare_network_for_vm_instance
,
3976 mock_reload_connection
,
3979 """New VM instance creation is successful."""
3981 mock_create_user_data
.return_value
= True, "userdata"
3983 mock_get_vm_availability_zone
.return_value
= "nova"
3985 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
3987 mock_time
.return_value
= time_return_value
3989 expected_result
= self
.server
.id, {}
3991 result
= self
.vimconn
.new_vminstance(
3997 affinity_group_list
,
4001 availability_zone_index
,
4002 availability_zone_list
,
4004 self
.assertEqual(result
, expected_result
)
4006 mock_reload_connection
.assert_called_once()
4007 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4012 external_network
=[],
4013 no_secured_ports
=[],
4015 mock_create_user_data
.assert_called_once_with(cloud_config
)
4016 mock_get_vm_availability_zone
.assert_called_once_with(
4017 availability_zone_index
, availability_zone_list
4019 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4021 existing_vim_volumes
=[],
4024 disk_list
=disk_list2
,
4026 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4031 security_groups
="default",
4032 availability_zone
="nova",
4033 key_name
="my_keypair",
4034 userdata
="userdata",
4036 block_device_mapping
=None,
4039 mock_time
.assert_called_once()
4040 mock_update_port_security
.assert_called_once_with([], self
.server
)
4041 mock_prepare_external_network
.assert_called_once_with(
4042 external_network
=[],
4045 vm_start_time
=time_return_value
,
4047 mock_delete_vm_instance
.assert_not_called()
4048 mock_format_exception
.assert_not_called()
4051 @patch.object(vimconnector
, "_reload_connection")
4052 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4053 @patch.object(vimconnector
, "_create_user_data")
4054 @patch.object(vimconnector
, "_get_vm_availability_zone")
4055 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4056 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4057 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4058 @patch.object(vimconnector
, "delete_vminstance")
4059 @patch.object(vimconnector
, "_format_exception")
4060 def test_new_vm_instance_create_user_data_fails(
4062 mock_format_exception
,
4063 mock_delete_vm_instance
,
4064 mock_prepare_external_network
,
4065 mock_update_port_security
,
4066 mock_prepare_disk_for_vm_instance
,
4067 mock_get_vm_availability_zone
,
4068 mock_create_user_data
,
4069 mock_prepare_network_for_vm_instance
,
4070 mock_reload_connection
,
4073 """New VM instance creation failed because of user data creation failure."""
4075 mock_create_user_data
.side_effect
= Exception(
4076 "User data could not be retrieved."
4079 mock_get_vm_availability_zone
.return_value
= "nova"
4081 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4083 mock_time
.return_value
= time_return_value
4085 self
.vimconn
.new_vminstance(
4091 affinity_group_list
,
4095 availability_zone_index
,
4096 availability_zone_list
,
4099 mock_reload_connection
.assert_called_once()
4100 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4105 external_network
=[],
4106 no_secured_ports
=[],
4108 mock_create_user_data
.assert_called_once_with(cloud_config
)
4109 mock_get_vm_availability_zone
.assert_not_called()
4110 mock_prepare_disk_for_vm_instance
.assert_not_called()
4111 self
.vimconn
.nova
.servers
.create
.assert_not_called()
4112 mock_time
.assert_not_called()
4113 mock_update_port_security
.assert_not_called()
4114 mock_prepare_external_network
.assert_not_called()
4115 mock_delete_vm_instance
.assert_called_once_with(None, {})
4116 mock_format_exception
.assert_called_once()
4117 arg
= mock_format_exception
.call_args
[0][0]
4118 self
.assertEqual(str(arg
), "User data could not be retrieved.")
4121 @patch.object(vimconnector
, "_reload_connection")
4122 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4123 @patch.object(vimconnector
, "_create_user_data")
4124 @patch.object(vimconnector
, "_get_vm_availability_zone")
4125 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4126 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4127 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4128 @patch.object(vimconnector
, "delete_vminstance")
4129 @patch.object(vimconnector
, "_format_exception")
4130 def test_new_vm_instance_external_network_exception(
4132 mock_format_exception
,
4133 mock_delete_vm_instance
,
4134 mock_prepare_external_network
,
4135 mock_update_port_security
,
4136 mock_prepare_disk_for_vm_instance
,
4137 mock_get_vm_availability_zone
,
4138 mock_create_user_data
,
4139 mock_prepare_network_for_vm_instance
,
4140 mock_reload_connection
,
4143 """New VM instance creation, external network connection has failed as floating
4144 ip could not be created."""
4146 mock_create_user_data
.return_value
= True, "userdata"
4148 mock_get_vm_availability_zone
.return_value
= "nova"
4150 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4152 mock_time
.return_value
= time_return_value
4154 mock_prepare_external_network
.side_effect
= VimConnException(
4155 "Can not create floating ip."
4158 self
.vimconn
.new_vminstance(
4164 affinity_group_list
,
4168 availability_zone_index
,
4169 availability_zone_list
,
4172 mock_reload_connection
.assert_called_once()
4173 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4178 external_network
=[],
4179 no_secured_ports
=[],
4181 mock_create_user_data
.assert_called_once_with(cloud_config
)
4182 mock_get_vm_availability_zone
.assert_called_once_with(
4183 availability_zone_index
, availability_zone_list
4185 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4187 existing_vim_volumes
=[],
4190 disk_list
=disk_list2
,
4192 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4197 security_groups
="default",
4198 availability_zone
="nova",
4199 key_name
="my_keypair",
4200 userdata
="userdata",
4202 block_device_mapping
=None,
4205 mock_time
.assert_called_once()
4206 mock_update_port_security
.assert_called_once_with([], self
.server
)
4207 mock_prepare_external_network
.assert_called_once_with(
4208 external_network
=[],
4211 vm_start_time
=time_return_value
,
4213 mock_delete_vm_instance
.assert_called_once_with(self
.server
.id, {})
4214 mock_format_exception
.assert_called_once()
4215 arg
= mock_format_exception
.call_args
[0][0]
4216 self
.assertEqual(str(arg
), "Can not create floating ip.")
4219 @patch.object(vimconnector
, "_reload_connection")
4220 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4221 @patch.object(vimconnector
, "_create_user_data")
4222 @patch.object(vimconnector
, "_get_vm_availability_zone")
4223 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4224 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4225 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4226 @patch.object(vimconnector
, "delete_vminstance")
4227 @patch.object(vimconnector
, "_format_exception")
4228 def test_new_vm_instance_with_affinity_group(
4230 mock_format_exception
,
4231 mock_delete_vm_instance
,
4232 mock_prepare_external_network
,
4233 mock_update_port_security
,
4234 mock_prepare_disk_for_vm_instance
,
4235 mock_get_vm_availability_zone
,
4236 mock_create_user_data
,
4237 mock_prepare_network_for_vm_instance
,
4238 mock_reload_connection
,
4241 """New VM creation with affinity group."""
4242 affinity_group_list
= [
4243 {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
4245 mock_create_user_data
.return_value
= True, "userdata"
4246 mock_get_vm_availability_zone
.return_value
= "nova"
4247 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4248 mock_time
.return_value
= time_return_value
4249 expected_result
= self
.server
.id, {}
4251 result
= self
.vimconn
.new_vminstance(
4257 affinity_group_list
,
4261 availability_zone_index
,
4262 availability_zone_list
,
4264 self
.assertEqual(result
, expected_result
)
4266 mock_reload_connection
.assert_called_once()
4267 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4272 external_network
=[],
4273 no_secured_ports
=[],
4275 mock_create_user_data
.assert_called_once_with(cloud_config
)
4276 mock_get_vm_availability_zone
.assert_called_once_with(
4277 availability_zone_index
, availability_zone_list
4279 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4281 existing_vim_volumes
=[],
4284 disk_list
=disk_list2
,
4286 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4291 security_groups
="default",
4292 availability_zone
="nova",
4293 key_name
="my_keypair",
4294 userdata
="userdata",
4296 block_device_mapping
=None,
4297 scheduler_hints
={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
4299 mock_time
.assert_called_once()
4300 mock_update_port_security
.assert_called_once_with([], self
.server
)
4301 mock_prepare_external_network
.assert_called_once_with(
4302 external_network
=[],
4305 vm_start_time
=time_return_value
,
4307 mock_delete_vm_instance
.assert_not_called()
4308 mock_format_exception
.assert_not_called()
4311 @patch.object(vimconnector
, "_reload_connection")
4312 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4313 @patch.object(vimconnector
, "_create_user_data")
4314 @patch.object(vimconnector
, "_get_vm_availability_zone")
4315 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4316 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4317 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4318 @patch.object(vimconnector
, "delete_vminstance")
4319 @patch.object(vimconnector
, "_format_exception")
4320 def test_new_vm_instance_nova_server_create_failed(
4322 mock_format_exception
,
4323 mock_delete_vm_instance
,
4324 mock_prepare_external_network
,
4325 mock_update_port_security
,
4326 mock_prepare_disk_for_vm_instance
,
4327 mock_get_vm_availability_zone
,
4328 mock_create_user_data
,
4329 mock_prepare_network_for_vm_instance
,
4330 mock_reload_connection
,
4333 """New VM(server) creation failed."""
4335 mock_create_user_data
.return_value
= True, "userdata"
4337 mock_get_vm_availability_zone
.return_value
= "nova"
4339 self
.vimconn
.nova
.servers
.create
.side_effect
= Exception(
4340 "Server could not be created."
4343 mock_time
.return_value
= time_return_value
4345 self
.vimconn
.new_vminstance(
4351 affinity_group_list
,
4355 availability_zone_index
,
4356 availability_zone_list
,
4359 mock_reload_connection
.assert_called_once()
4360 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4365 external_network
=[],
4366 no_secured_ports
=[],
4368 mock_create_user_data
.assert_called_once_with(cloud_config
)
4369 mock_get_vm_availability_zone
.assert_called_once_with(
4370 availability_zone_index
, availability_zone_list
4372 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4374 existing_vim_volumes
=[],
4377 disk_list
=disk_list2
,
4380 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4385 security_groups
="default",
4386 availability_zone
="nova",
4387 key_name
="my_keypair",
4388 userdata
="userdata",
4390 block_device_mapping
=None,
4393 mock_time
.assert_not_called()
4394 mock_update_port_security
.assert_not_called()
4395 mock_prepare_external_network
.assert_not_called()
4396 mock_delete_vm_instance
.assert_called_once_with(None, {})
4397 mock_format_exception
.assert_called_once()
4398 arg
= mock_format_exception
.call_args
[0][0]
4399 self
.assertEqual(str(arg
), "Server could not be created.")
4402 @patch.object(vimconnector
, "_reload_connection")
4403 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4404 @patch.object(vimconnector
, "_create_user_data")
4405 @patch.object(vimconnector
, "_get_vm_availability_zone")
4406 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4407 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4408 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4409 @patch.object(vimconnector
, "delete_vminstance")
4410 @patch.object(vimconnector
, "_format_exception")
4411 def test_new_vm_instance_connection_exception(
4413 mock_format_exception
,
4414 mock_delete_vm_instance
,
4415 mock_prepare_external_network
,
4416 mock_update_port_security
,
4417 mock_prepare_disk_for_vm_instance
,
4418 mock_get_vm_availability_zone
,
4419 mock_create_user_data
,
4420 mock_prepare_network_for_vm_instance
,
4421 mock_reload_connection
,
4424 """Connection to Cloud API has failed."""
4425 mock_reload_connection
.side_effect
= Exception("Can not connect to Cloud APIs.")
4426 mock_create_user_data
.return_value
= True, "userdata"
4427 mock_get_vm_availability_zone
.return_value
= "nova"
4428 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4429 mock_time
.return_value
= time_return_value
4431 self
.vimconn
.new_vminstance(
4437 affinity_group_list
,
4441 availability_zone_index
,
4442 availability_zone_list
,
4444 mock_format_exception
.assert_called_once()
4445 arg
= mock_format_exception
.call_args
[0][0]
4446 self
.assertEqual(str(arg
), "Can not connect to Cloud APIs.")
4447 mock_reload_connection
.assert_called_once()
4448 mock_prepare_network_for_vm_instance
.assert_not_called()
4449 mock_create_user_data
.assert_not_called()
4450 mock_get_vm_availability_zone
.assert_not_called()
4451 mock_prepare_disk_for_vm_instance
.assert_not_called()
4452 self
.vimconn
.nova
.servers
.create
.assert_not_called()
4453 mock_time
.assert_not_called()
4454 mock_update_port_security
.assert_not_called()
4455 mock_prepare_external_network
.assert_not_called()
4456 mock_delete_vm_instance
.assert_called_once_with(None, {})
4458 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4459 def test_delete_vm_ports_attached_to_network_empty_created_items(
4460 self
, mock_delete_ports_by_id_wth_neutron
4462 """Created_items is emtpty."""
4464 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4465 self
.vimconn
.neutron
.list_ports
.assert_not_called()
4466 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4467 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4469 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4470 def test_delete_vm_ports_attached_to_network(
4471 self
, mock_delete_ports_by_id_wth_neutron
4474 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
4475 f
"volume:{volume_id2}": True,
4476 f
"volume:{volume_id}": True,
4477 f
"port:{port_id}": True,
4479 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4480 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4481 self
.vimconn
.logger
.error
.assert_not_called()
4483 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4484 def test_delete_vm_ports_attached_to_network_wthout_port(
4485 self
, mock_delete_ports_by_id_wth_neutron
4487 """Created_items does not have port."""
4489 f
"floating_ip:{floating_network_vim_id}": True,
4490 f
"volume:{volume_id2}": True,
4491 f
"volume:{volume_id}": True,
4493 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4494 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4495 self
.vimconn
.logger
.error
.assert_not_called()
4497 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4498 def test_delete_vm_ports_attached_to_network_delete_port_raise_vimconnexception(
4499 self
, mock_delete_ports_by_id_wth_neutron
4501 """_delete_ports_by_id_wth_neutron raises vimconnexception."""
4502 created_items
= deepcopy(created_items_all_true
)
4503 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
4504 "Can not delete port"
4506 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4507 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4508 self
.vimconn
.logger
.error
.assert_called_once_with(
4509 "Error deleting port: VimConnException: Can not delete port"
4512 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4513 def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
4514 self
, mock_delete_ports_by_id_wth_neutron
4516 """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
4517 created_items
= deepcopy(created_items_all_true
)
4518 mock_delete_ports_by_id_wth_neutron
.side_effect
= nvExceptions
.ClientException(
4519 "Connection aborted."
4521 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4522 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4523 self
.vimconn
.logger
.error
.assert_called_once_with(
4524 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4527 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4528 def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
4529 self
, mock_delete_ports_by_id_wth_neutron
4531 """port item is invalid."""
4533 f
"floating_ip:{floating_network_vim_id}": True,
4534 f
"volume:{volume_id2}": True,
4535 f
"volume:{volume_id}": True,
4536 f
"port:{port_id}:": True,
4538 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
4539 "Port is not valid."
4541 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4542 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}:")
4543 self
.vimconn
.logger
.error
.assert_called_once_with(
4544 "Error deleting port: VimConnException: Port is not valid."
4547 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4548 def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
4549 self
, mock_delete_ports_by_id_wth_neutron
4551 """port is already deleted."""
4553 f
"floating_ip:{floating_network_vim_id}": True,
4554 f
"volume:{volume_id2}": True,
4555 f
"volume:{volume_id}": None,
4556 f
"port:{port_id}": None,
4558 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4559 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4560 self
.vimconn
.logger
.error
.assert_not_called()
4562 def test_delete_floating_ip_by_id(self
):
4564 f
"floating_ip:{floating_network_vim_id}": True,
4565 f
"port:{port_id}": True,
4567 expected_created_items
= {
4568 f
"floating_ip:{floating_network_vim_id}": None,
4569 f
"port:{port_id}": True,
4571 k_id
= floating_network_vim_id
4572 k
= f
"floating_ip:{floating_network_vim_id}"
4573 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4574 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4575 self
.assertEqual(created_items
, expected_created_items
)
4577 def test_delete_floating_ip_by_id_floating_ip_already_deleted(self
):
4578 """floating ip is already deleted."""
4580 f
"floating_ip:{floating_network_vim_id}": None,
4581 f
"port:{port_id}": True,
4583 k_id
= floating_network_vim_id
4584 k
= f
"floating_ip:{floating_network_vim_id}"
4585 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4586 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4590 f
"floating_ip:{floating_network_vim_id}": None,
4591 f
"port:{port_id}": True,
4595 def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self
):
4596 """netron delete floating ip raises nvExceptions.ClientException."""
4598 f
"floating_ip:{floating_network_vim_id}": True,
4599 f
"port:{port_id}": True,
4601 k_id
= floating_network_vim_id
4602 k
= f
"floating_ip:{floating_network_vim_id}"
4603 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= (
4604 nvExceptions
.ClientException("Client exception occurred.")
4606 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4607 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4611 f
"floating_ip:{floating_network_vim_id}": True,
4612 f
"port:{port_id}": True,
4615 self
.vimconn
.logger
.error
.assert_called_once_with(
4616 "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occurred.)"
4619 def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self
):
4620 """netron delete floating ip raises VimConnNotFoundException."""
4622 f
"floating_ip:{floating_network_vim_id}": True,
4623 f
"port:{port_id}": True,
4625 k_id
= floating_network_vim_id
4626 k
= f
"floating_ip:{floating_network_vim_id}"
4627 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= VimConnNotFoundException(
4628 "Port id could not found."
4630 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4631 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4635 f
"floating_ip:{floating_network_vim_id}": True,
4636 f
"port:{port_id}": True,
4639 self
.vimconn
.logger
.error
.assert_called_once_with(
4640 "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
4643 def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self
):
4644 """invalid floating ip item."""
4646 f
"floating_ip:{floating_network_vim_id}": True,
4647 f
"port:{port_id}": True,
4649 expected_created_items
= {
4650 f
"floating_ip:{floating_network_vim_id}::": None,
4651 f
"floating_ip:{floating_network_vim_id}": True,
4652 f
"port:{port_id}": True,
4654 k_id
= floating_network_vim_id
4655 k
= f
"floating_ip:{floating_network_vim_id}::"
4656 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4657 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4658 self
.assertEqual(created_items
, expected_created_items
)
4660 def test_delete_volumes_by_id_with_cinder_volume_status_available(self
):
4661 """volume status is available."""
4663 f
"floating_ip:{floating_network_vim_id}": True,
4664 f
"volume:{volume_id2}": True,
4665 f
"volume:{volume_id}": True,
4666 f
"port:{port_id}": None,
4668 expected_created_items
= {
4669 f
"floating_ip:{floating_network_vim_id}": True,
4670 f
"volume:{volume_id2}": True,
4671 f
"volume:{volume_id}": None,
4672 f
"port:{port_id}": None,
4674 volumes_to_hold
= []
4675 k
= f
"volume:{volume_id}"
4677 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4678 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4679 k
, k_id
, volumes_to_hold
, created_items
4681 self
.assertEqual(result
, None)
4682 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4683 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4684 self
.vimconn
.logger
.error
.assert_not_called()
4685 self
.assertEqual(created_items
, expected_created_items
)
4687 def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self
):
4688 """volume is already deleted."""
4690 f
"floating_ip:{floating_network_vim_id}": True,
4691 f
"volume:{volume_id2}": True,
4692 f
"volume:{volume_id}": None,
4693 f
"port:{port_id}": None,
4695 expected_created_items
= {
4696 f
"floating_ip:{floating_network_vim_id}": True,
4697 f
"volume:{volume_id2}": True,
4698 f
"volume:{volume_id}": None,
4699 f
"port:{port_id}": None,
4701 volumes_to_hold
= []
4702 k
= f
"volume:{volume_id}"
4704 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4705 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4706 k
, k_id
, volumes_to_hold
, created_items
4708 self
.assertEqual(result
, None)
4709 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4710 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4711 self
.vimconn
.logger
.error
.assert_not_called()
4712 self
.assertEqual(created_items
, expected_created_items
)
4714 def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self
):
4715 """cinder get volume raises exception."""
4717 f
"floating_ip:{floating_network_vim_id}": True,
4718 f
"volume:{volume_id2}": True,
4719 f
"volume:{volume_id}": True,
4720 f
"port:{port_id}": None,
4722 expected_created_items
= {
4723 f
"floating_ip:{floating_network_vim_id}": True,
4724 f
"volume:{volume_id2}": True,
4725 f
"volume:{volume_id}": True,
4726 f
"port:{port_id}": None,
4728 volumes_to_hold
= []
4729 k
= f
"volume:{volume_id}"
4731 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception(
4732 "Can not get volume status."
4734 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4735 k
, k_id
, volumes_to_hold
, created_items
4737 self
.assertEqual(result
, None)
4738 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4739 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4740 self
.vimconn
.logger
.error
.assert_called_once_with(
4741 "Error deleting volume: Exception: Can not get volume status."
4743 self
.assertEqual(created_items
, expected_created_items
)
4745 def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self
):
4746 """cinder delete volume raises exception."""
4748 f
"floating_ip:{floating_network_vim_id}": True,
4749 f
"volume:{volume_id2}": True,
4750 f
"volume:{volume_id}": True,
4751 f
"port:{port_id}": None,
4753 expected_created_items
= {
4754 f
"floating_ip:{floating_network_vim_id}": True,
4755 f
"volume:{volume_id2}": True,
4756 f
"volume:{volume_id}": True,
4757 f
"port:{port_id}": None,
4759 volumes_to_hold
= []
4760 k
= f
"volume:{volume_id}"
4762 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4763 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= nvExceptions
.ClientException(
4764 "Connection aborted."
4766 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4767 k
, k_id
, volumes_to_hold
, created_items
4769 self
.assertEqual(result
, None)
4770 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4771 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4772 self
.vimconn
.logger
.error
.assert_called_once_with(
4773 "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
4775 self
.assertEqual(created_items
, expected_created_items
)
4777 def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self
):
4778 """volume_to_hold has item."""
4780 f
"floating_ip:{floating_network_vim_id}": True,
4781 f
"volume:{volume_id2}": True,
4782 f
"volume:{volume_id}": True,
4783 f
"port:{port_id}": None,
4785 expected_created_items
= {
4786 f
"floating_ip:{floating_network_vim_id}": True,
4787 f
"volume:{volume_id2}": True,
4788 f
"volume:{volume_id}": True,
4789 f
"port:{port_id}": None,
4791 volumes_to_hold
= [volume_id
]
4792 k
= f
"volume:{volume_id}"
4794 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4795 k
, k_id
, volumes_to_hold
, created_items
4797 self
.assertEqual(result
, None)
4798 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
4799 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4800 self
.vimconn
.logger
.error
.assert_not_called()
4801 self
.assertEqual(created_items
, expected_created_items
)
4803 def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self
):
4804 """volume status is not available."""
4806 f
"floating_ip:{floating_network_vim_id}": True,
4807 f
"volume:{volume_id2}": True,
4808 f
"volume:{volume_id}": True,
4809 f
"port:{port_id}": None,
4811 expected_created_items
= {
4812 f
"floating_ip:{floating_network_vim_id}": True,
4813 f
"volume:{volume_id2}": True,
4814 f
"volume:{volume_id}": True,
4815 f
"port:{port_id}": None,
4817 volumes_to_hold
= []
4818 k
= f
"volume:{volume_id}"
4820 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "unavailable"
4821 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4822 k
, k_id
, volumes_to_hold
, created_items
4824 self
.assertEqual(result
, True)
4825 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4826 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4827 self
.vimconn
.logger
.error
.assert_not_called()
4828 self
.assertEqual(created_items
, expected_created_items
)
4830 def test_delete_ports_by_id_by_neutron(self
):
4831 """neutron delete ports."""
4833 self
.vimconn
.neutron
.list_ports
.return_value
= {
4834 "ports": [{"id": port_id
}, {"id": port2_id
}]
4837 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4838 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4839 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4840 self
.vimconn
.logger
.error
.assert_not_called()
4842 def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self
):
4843 """port id not in the port list."""
4845 self
.vimconn
.neutron
.list_ports
.return_value
= {
4846 "ports": [{"id": port_id
}, {"id": port2_id
}]
4849 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4850 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4851 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4852 self
.vimconn
.logger
.error
.assert_not_called()
4854 def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self
):
4855 """neutron list port raises exception."""
4857 self
.vimconn
.neutron
.list_ports
.side_effect
= nvExceptions
.ClientException(
4858 "Connection aborted."
4860 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4861 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4862 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4863 self
.vimconn
.logger
.error
.assert_called_once_with(
4864 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4867 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
4868 """neutron delete port raises exception."""
4870 self
.vimconn
.neutron
.list_ports
.return_value
= {
4871 "ports": [{"id": port_id
}, {"id": port2_id
}]
4873 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
4874 "Connection aborted."
4876 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4877 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4878 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4879 self
.vimconn
.logger
.error
.assert_called_once_with(
4880 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4883 def test_get_item_name_id(self
):
4884 """Get name and id successfully."""
4885 k
= f
"some:{port_id}"
4886 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4887 self
.assertEqual(result
, ("some", f
"{port_id}"))
4889 def test_get_item_name_id_wthout_semicolon(self
):
4890 """Does not have seperator."""
4891 k
= f
"some{port_id}"
4892 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4893 self
.assertEqual(result
, (f
"some{port_id}", ""))
4895 def test_get_item_name_id_empty_string(self
):
4898 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4899 self
.assertEqual(result
, ("", ""))
4901 def test_get_item_name_id_k_is_none(self
):
4904 with self
.assertRaises(AttributeError):
4905 self
.vimconn
._get
_item
_name
_id
(k
)
4907 @patch.object(vimconnector
, "_get_item_name_id")
4908 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4909 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4910 def test_delete_created_items(
4912 mock_delete_floating_ip_by_id
,
4913 mock_delete_volumes_by_id_wth_cinder
,
4914 mock_get_item_name_id
,
4916 """Created items has floating ip and volume."""
4918 f
"floating_ip:{floating_network_vim_id}": True,
4919 f
"volume:{volume_id}": True,
4920 f
"port:{port_id}": None,
4922 mock_get_item_name_id
.side_effect
= [
4923 ("floating_ip", f
"{floating_network_vim_id}"),
4924 ("volume", f
"{volume_id}"),
4926 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4927 volumes_to_hold
= []
4928 keep_waiting
= False
4929 result
= self
.vimconn
._delete
_created
_items
(
4930 created_items
, volumes_to_hold
, keep_waiting
4932 self
.assertEqual(result
, True)
4933 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4934 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4935 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4937 mock_delete_floating_ip_by_id
.assert_called_once_with(
4938 f
"floating_ip:{floating_network_vim_id}",
4939 f
"{floating_network_vim_id}",
4942 self
.vimconn
.logger
.error
.assert_not_called()
4944 @patch.object(vimconnector
, "_get_item_name_id")
4945 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4946 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4947 def test_delete_created_items_wth_volumes_to_hold(
4949 mock_delete_floating_ip_by_id
,
4950 mock_delete_volumes_by_id_wth_cinder
,
4951 mock_get_item_name_id
,
4953 """Created items has floating ip and volume and volumes_to_hold has items."""
4955 f
"floating_ip:{floating_network_vim_id}": True,
4956 f
"volume:{volume_id}": True,
4957 f
"port:{port_id}": None,
4959 mock_get_item_name_id
.side_effect
= [
4960 ("floating_ip", f
"{floating_network_vim_id}"),
4961 ("volume", f
"{volume_id}"),
4963 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4964 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
4965 keep_waiting
= False
4966 result
= self
.vimconn
._delete
_created
_items
(
4967 created_items
, volumes_to_hold
, keep_waiting
4969 self
.assertEqual(result
, True)
4970 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4971 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4972 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
4974 mock_delete_floating_ip_by_id
.assert_called_once_with(
4975 f
"floating_ip:{floating_network_vim_id}",
4976 f
"{floating_network_vim_id}",
4979 self
.vimconn
.logger
.error
.assert_not_called()
4981 @patch.object(vimconnector
, "_get_item_name_id")
4982 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4983 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4984 def test_delete_created_items_wth_keep_waiting_true(
4986 mock_delete_floating_ip_by_id
,
4987 mock_delete_volumes_by_id_wth_cinder
,
4988 mock_get_item_name_id
,
4990 """Keep waiting initial value is True."""
4992 f
"floating_ip:{floating_network_vim_id}": True,
4993 f
"volume:{volume_id}": True,
4994 f
"port:{port_id}": None,
4996 mock_get_item_name_id
.side_effect
= [
4997 ("floating_ip", f
"{floating_network_vim_id}"),
4998 ("volume", f
"{volume_id}"),
5000 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5001 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5003 result
= self
.vimconn
._delete
_created
_items
(
5004 created_items
, volumes_to_hold
, keep_waiting
5006 self
.assertEqual(result
, True)
5007 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5008 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5009 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
5011 mock_delete_floating_ip_by_id
.assert_called_once_with(
5012 f
"floating_ip:{floating_network_vim_id}",
5013 f
"{floating_network_vim_id}",
5016 self
.vimconn
.logger
.error
.assert_not_called()
5018 @patch.object(vimconnector
, "_get_item_name_id")
5019 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5020 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5021 def test_delete_created_items_delete_vol_raises(
5023 mock_delete_floating_ip_by_id
,
5024 mock_delete_volumes_by_id_wth_cinder
,
5025 mock_get_item_name_id
,
5027 """Delete volume raises exception."""
5029 f
"floating_ip:{floating_network_vim_id}": True,
5030 f
"volume:{volume_id}": True,
5031 f
"port:{port_id}": None,
5033 mock_get_item_name_id
.side_effect
= [
5034 ("floating_ip", f
"{floating_network_vim_id}"),
5035 ("volume", f
"{volume_id}"),
5037 mock_delete_volumes_by_id_wth_cinder
.side_effect
= ConnectionError(
5038 "Connection failed."
5040 volumes_to_hold
= []
5041 keep_waiting
= False
5042 result
= self
.vimconn
._delete
_created
_items
(
5043 created_items
, volumes_to_hold
, keep_waiting
5045 self
.assertEqual(result
, False)
5046 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5047 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5048 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5050 mock_delete_floating_ip_by_id
.assert_called_once_with(
5051 f
"floating_ip:{floating_network_vim_id}",
5052 f
"{floating_network_vim_id}",
5055 self
.vimconn
.logger
.error
.assert_called_once_with(
5056 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
5059 @patch.object(vimconnector
, "_get_item_name_id")
5060 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5061 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5062 def test_delete_created_items_delete_fip_raises(
5064 mock_delete_floating_ip_by_id
,
5065 mock_delete_volumes_by_id_wth_cinder
,
5066 mock_get_item_name_id
,
5068 """Delete floating ip raises exception."""
5070 f
"floating_ip:{floating_network_vim_id}": True,
5071 f
"volume:{volume_id}": True,
5072 f
"port:{port_id}": None,
5074 mock_get_item_name_id
.side_effect
= [
5075 ("floating_ip", f
"{floating_network_vim_id}"),
5076 ("volume", f
"{volume_id}"),
5078 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5079 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
5080 "Connection failed."
5082 volumes_to_hold
= []
5084 result
= self
.vimconn
._delete
_created
_items
(
5085 created_items
, volumes_to_hold
, keep_waiting
5087 self
.assertEqual(result
, True)
5088 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5089 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5090 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5092 mock_delete_floating_ip_by_id
.assert_called_once_with(
5093 f
"floating_ip:{floating_network_vim_id}",
5094 f
"{floating_network_vim_id}",
5097 self
.vimconn
.logger
.error
.assert_called_once_with(
5098 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
5101 @patch.object(vimconnector
, "_get_item_name_id")
5102 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5103 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5104 def test_delete_created_items_get_item_name_raises(
5106 mock_delete_floating_ip_by_id
,
5107 mock_delete_volumes_by_id_wth_cinder
,
5108 mock_get_item_name_id
,
5110 """Get item, name raises exception."""
5113 f
"volume{volume_id}": True,
5114 f
"port:{port_id}": None,
5116 mock_get_item_name_id
.side_effect
= [
5117 TypeError("Invalid Type"),
5118 AttributeError("Invalid attribute"),
5120 volumes_to_hold
= []
5121 keep_waiting
= False
5122 result
= self
.vimconn
._delete
_created
_items
(
5123 created_items
, volumes_to_hold
, keep_waiting
5125 self
.assertEqual(result
, False)
5126 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5127 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5128 mock_delete_floating_ip_by_id
.assert_not_called()
5129 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
5130 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
5133 (f
"Error deleting volume{volume_id}: Invalid attribute",),
5136 @patch.object(vimconnector
, "_get_item_name_id")
5137 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5138 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5139 def test_delete_created_items_no_fip_wth_port(
5141 mock_delete_floating_ip_by_id
,
5142 mock_delete_volumes_by_id_wth_cinder
,
5143 mock_get_item_name_id
,
5145 """Created items has port, does not have floating ip."""
5147 f
"volume:{volume_id}": True,
5148 f
"port:{port_id}": True,
5150 mock_get_item_name_id
.side_effect
= [
5151 ("volume", f
"{volume_id}"),
5152 ("port", f
"{port_id}"),
5154 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5155 volumes_to_hold
= []
5156 keep_waiting
= False
5157 result
= self
.vimconn
._delete
_created
_items
(
5158 created_items
, volumes_to_hold
, keep_waiting
5160 self
.assertEqual(result
, False)
5161 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5162 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5163 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5165 mock_delete_floating_ip_by_id
.assert_not_called()
5166 self
.vimconn
.logger
.error
.assert_not_called()
5168 @patch.object(vimconnector
, "_get_item_name_id")
5169 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5170 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5171 def test_delete_created_items_no_volume(
5173 mock_delete_floating_ip_by_id
,
5174 mock_delete_volumes_by_id_wth_cinder
,
5175 mock_get_item_name_id
,
5177 """Created items does not have volume."""
5179 f
"floating_ip:{floating_network_vim_id}": True,
5180 f
"port:{port_id}": None,
5182 mock_get_item_name_id
.side_effect
= [
5183 ("floating_ip", f
"{floating_network_vim_id}")
5185 volumes_to_hold
= []
5186 keep_waiting
= False
5187 result
= self
.vimconn
._delete
_created
_items
(
5188 created_items
, volumes_to_hold
, keep_waiting
5190 self
.assertEqual(result
, False)
5191 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
5192 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5193 mock_delete_floating_ip_by_id
.assert_called_once_with(
5194 f
"floating_ip:{floating_network_vim_id}",
5195 f
"{floating_network_vim_id}",
5198 self
.vimconn
.logger
.error
.assert_not_called()
5200 @patch.object(vimconnector
, "_get_item_name_id")
5201 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5202 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5203 def test_delete_created_items_already_deleted(
5205 mock_delete_floating_ip_by_id
,
5206 mock_delete_volumes_by_id_wth_cinder
,
5207 mock_get_item_name_id
,
5209 """All created items are alerady deleted."""
5211 f
"floating_ip:{floating_network_vim_id}": None,
5212 f
"volume:{volume_id}": None,
5213 f
"port:{port_id}": None,
5215 volumes_to_hold
= []
5216 keep_waiting
= False
5217 result
= self
.vimconn
._delete
_created
_items
(
5218 created_items
, volumes_to_hold
, keep_waiting
5220 self
.assertEqual(result
, False)
5221 mock_get_item_name_id
.assert_not_called()
5222 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5223 mock_delete_floating_ip_by_id
.assert_not_called()
5224 self
.vimconn
.logger
.error
.assert_not_called()
5226 @patch("time.sleep")
5227 @patch.object(vimconnector
, "_format_exception")
5228 @patch.object(vimconnector
, "_reload_connection")
5229 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5230 @patch.object(vimconnector
, "_delete_created_items")
5231 def test_delete_vminstance_successfully(
5233 mock_delete_created_items
,
5234 mock_delete_vm_ports_attached_to_network
,
5235 mock_reload_connection
,
5236 mock_format_exception
,
5239 vm_id
= f
"{virtual_mac_id}"
5240 created_items
= deepcopy(created_items_all_true
)
5241 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5242 mock_delete_created_items
.return_value
= False
5243 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5244 mock_reload_connection
.assert_called_once()
5245 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5246 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5247 mock_delete_created_items
.assert_called_once_with(
5248 created_items
, volumes_to_hold
, False
5250 mock_sleep
.assert_not_called()
5251 mock_format_exception
.assert_not_called()
5253 @patch("time.sleep")
5254 @patch.object(vimconnector
, "_format_exception")
5255 @patch.object(vimconnector
, "_reload_connection")
5256 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5257 @patch.object(vimconnector
, "_delete_created_items")
5258 def test_delete_vminstance_delete_created_items_raises(
5260 mock_delete_created_items
,
5261 mock_delete_vm_ports_attached_to_network
,
5262 mock_reload_connection
,
5263 mock_format_exception
,
5266 """Delete creted items raises exception."""
5267 vm_id
= f
"{virtual_mac_id}"
5268 created_items
= deepcopy(created_items_all_true
)
5269 mock_sleep
= MagicMock()
5270 volumes_to_hold
= []
5271 err
= ConnectionError("ClientException occurred.")
5272 mock_delete_created_items
.side_effect
= err
5273 with self
.assertRaises(ConnectionError
) as err
:
5274 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5275 self
.assertEqual(str(err
), "ClientException occurred.")
5276 mock_reload_connection
.assert_called_once()
5277 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5278 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5279 mock_delete_created_items
.assert_called_once()
5280 mock_sleep
.assert_not_called()
5282 @patch("time.sleep")
5283 @patch.object(vimconnector
, "_format_exception")
5284 @patch.object(vimconnector
, "_reload_connection")
5285 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5286 @patch.object(vimconnector
, "_delete_created_items")
5287 def test_delete_vminstance_delete_vm_ports_raises(
5289 mock_delete_created_items
,
5290 mock_delete_vm_ports_attached_to_network
,
5291 mock_reload_connection
,
5292 mock_format_exception
,
5295 """Delete vm ports raises exception."""
5296 vm_id
= f
"{virtual_mac_id}"
5297 created_items
= deepcopy(created_items_all_true
)
5298 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5299 err
= ConnectionError("ClientException occurred.")
5300 mock_delete_vm_ports_attached_to_network
.side_effect
= err
5301 mock_delete_created_items
.side_effect
= err
5302 with self
.assertRaises(ConnectionError
) as err
:
5303 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5304 self
.assertEqual(str(err
), "ClientException occurred.")
5305 mock_reload_connection
.assert_called_once()
5306 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5307 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5308 mock_delete_created_items
.assert_not_called()
5309 mock_sleep
.assert_not_called()
5311 @patch("time.sleep")
5312 @patch.object(vimconnector
, "_format_exception")
5313 @patch.object(vimconnector
, "_reload_connection")
5314 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5315 @patch.object(vimconnector
, "_delete_created_items")
5316 def test_delete_vminstance_nova_server_delete_raises(
5318 mock_delete_created_items
,
5319 mock_delete_vm_ports_attached_to_network
,
5320 mock_reload_connection
,
5321 mock_format_exception
,
5324 """Nova server delete raises exception."""
5325 vm_id
= f
"{virtual_mac_id}"
5326 created_items
= deepcopy(created_items_all_true
)
5327 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5328 err
= VimConnConnectionException("ClientException occurred.")
5329 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
5330 mock_delete_created_items
.side_effect
= err
5331 with self
.assertRaises(VimConnConnectionException
) as err
:
5332 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5333 self
.assertEqual(str(err
), "ClientException occurred.")
5334 mock_reload_connection
.assert_called_once()
5335 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5336 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5337 mock_delete_created_items
.assert_not_called()
5338 mock_sleep
.assert_not_called()
5340 @patch("time.sleep")
5341 @patch.object(vimconnector
, "_format_exception")
5342 @patch.object(vimconnector
, "_reload_connection")
5343 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5344 @patch.object(vimconnector
, "_delete_created_items")
5345 def test_delete_vminstance_reload_connection_raises(
5347 mock_delete_created_items
,
5348 mock_delete_vm_ports_attached_to_network
,
5349 mock_reload_connection
,
5350 mock_format_exception
,
5353 """Reload connection raises exception."""
5354 vm_id
= f
"{virtual_mac_id}"
5355 created_items
= deepcopy(created_items_all_true
)
5356 mock_sleep
= MagicMock()
5357 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5358 err
= ConnectionError("ClientException occurred.")
5359 mock_delete_created_items
.return_value
= False
5360 mock_reload_connection
.side_effect
= err
5361 with self
.assertRaises(ConnectionError
) as err
:
5362 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5363 self
.assertEqual(str(err
), "ClientException occurred.")
5364 mock_reload_connection
.assert_called_once()
5365 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5366 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5367 mock_delete_created_items
.assert_not_called()
5368 mock_sleep
.assert_not_called()
5370 @patch("time.sleep")
5371 @patch.object(vimconnector
, "_format_exception")
5372 @patch.object(vimconnector
, "_reload_connection")
5373 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5374 @patch.object(vimconnector
, "_delete_created_items")
5375 def test_delete_vminstance_created_item_vol_to_hold_are_none(
5377 mock_delete_created_items
,
5378 mock_delete_vm_ports_attached_to_network
,
5379 mock_reload_connection
,
5380 mock_format_exception
,
5383 """created_items and volumes_to_hold are None."""
5384 vm_id
= f
"{virtual_mac_id}"
5385 created_items
= None
5386 volumes_to_hold
= None
5387 mock_delete_created_items
.return_value
= False
5388 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5389 mock_reload_connection
.assert_called_once()
5390 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5391 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5392 mock_delete_created_items
.assert_called_once_with({}, [], False)
5393 mock_sleep
.assert_not_called()
5394 mock_format_exception
.assert_not_called()
5396 @patch("time.sleep")
5397 @patch.object(vimconnector
, "_format_exception")
5398 @patch.object(vimconnector
, "_reload_connection")
5399 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5400 @patch.object(vimconnector
, "_delete_created_items")
5401 def test_delete_vminstance_vm_id_is_none(
5403 mock_delete_created_items
,
5404 mock_delete_vm_ports_attached_to_network
,
5405 mock_reload_connection
,
5406 mock_format_exception
,
5409 """vm_id is None."""
5411 created_items
= deepcopy(created_items_all_true
)
5412 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5413 mock_delete_created_items
.side_effect
= [True, True, False]
5414 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5415 mock_reload_connection
.assert_called_once()
5416 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5417 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5418 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
5419 self
.assertEqual(mock_sleep
.call_count
, 2)
5420 mock_format_exception
.assert_not_called()
5422 @patch("time.sleep")
5423 @patch.object(vimconnector
, "_format_exception")
5424 @patch.object(vimconnector
, "_reload_connection")
5425 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5426 @patch.object(vimconnector
, "_delete_created_items")
5427 def test_delete_vminstance_delete_created_items_return_true(
5429 mock_delete_created_items
,
5430 mock_delete_vm_ports_attached_to_network
,
5431 mock_reload_connection
,
5432 mock_format_exception
,
5435 """Delete created items always return True."""
5437 created_items
= deepcopy(created_items_all_true
)
5438 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5439 mock_delete_created_items
.side_effect
= [True] * 1800
5440 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5441 mock_reload_connection
.assert_called_once()
5442 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5443 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5444 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
5445 self
.assertEqual(mock_sleep
.call_count
, 1800)
5446 mock_format_exception
.assert_not_called()
5449 class TestNewFlavor(unittest
.TestCase
):
5450 @patch("logging.getLogger", autospec
=True)
5451 def setUp(self
, mock_logger
):
5452 # We are disabling the logging of exception not to print them to console.
5453 mock_logger
= logging
.getLogger()
5454 mock_logger
.disabled
= True
5455 self
.vimconn
= vimconnector(
5465 self
.vimconn
.nova
= CopyingMock(autospec
=True)
5466 self
.flavor1
= CopyingMock(autospec
=True, name
="sample-flavor")
5467 self
.flavor2
= CopyingMock(autospec
=True, name
="other-flavor")
5468 self
.new_flavor
= CopyingMock(autospec
=True, name
="new_flavor")
5469 self
.new_flavor
.id = "075d2482-5edb-43e3-91b3-234e65b6268a"
5470 self
.vimconn
.nova
.flavors
.create
.return_value
= self
.new_flavor
5473 def check_if_assert_not_called(mocks
: list):
5474 for mocking
in mocks
:
5475 mocking
.assert_not_called()
5477 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5478 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5479 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5482 "process_numa_paired_threads",
5483 new_callable
=CopyingMock(),
5485 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5486 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5487 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_vio(
5489 mock_process_numa_threads
,
5490 mock_process_numa_cores
,
5491 mock_process_numa_paired_threads
,
5492 mock_process_numa_vcpu
,
5493 mock_process_numa_memory
,
5494 mock_process_vio_numa_nodes
,
5496 """Process numa parameters, id, memory, vcpu exist, vim type is VIO,
5497 paired-threads, cores, threads do not exist in numa.
5500 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5501 {"id": 1, "memory": 2, "vcpu": [2]},
5504 expected_extra_specs
= {
5505 "hw:numa_nodes": "2",
5506 "hw:cpu_sockets": "2",
5508 self
.vimconn
.vim_type
= "VIO"
5509 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5511 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5512 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5513 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5514 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5516 _call_mock_process_numa_memory
[0].args
,
5518 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5521 "hw:numa_nodes": "2",
5526 _call_mock_process_numa_memory
[1].args
,
5528 {"id": 1, "memory": 2, "vcpu": [2]},
5531 "hw:cpu_sockets": "2",
5532 "hw:numa_nodes": "2",
5536 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5538 _call_mock_process_numa_vcpu
[0].args
,
5540 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5543 "hw:numa_nodes": "2",
5548 _call_mock_process_numa_vcpu
[1].args
,
5550 {"id": 1, "memory": 2, "vcpu": [2]},
5553 "hw:cpu_sockets": "2",
5554 "hw:numa_nodes": "2",
5558 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5559 self
.check_if_assert_not_called(
5561 mock_process_numa_threads
,
5562 mock_process_numa_cores
,
5563 mock_process_numa_paired_threads
,
5567 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5568 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5569 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5572 "process_numa_paired_threads",
5573 new_callable
=CopyingMock(),
5575 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5576 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5577 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_openstack(
5579 mock_process_numa_threads
,
5580 mock_process_numa_cores
,
5581 mock_process_numa_paired_threads
,
5582 mock_process_numa_vcpu
,
5583 mock_process_numa_memory
,
5584 mock_process_vio_numa_nodes
,
5586 """Process numa parameters, id, memory, vcpu exist, vim type is openstack,
5587 paired-threads, cores, threads do not exist in numa.
5590 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5591 {"id": 1, "memory": 2, "vcpu": [2]},
5594 expected_extra_specs
= {
5595 "hw:numa_nodes": "2",
5596 "hw:cpu_sockets": "2",
5598 self
.vimconn
.vim_type
= "openstack"
5599 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5601 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5602 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5603 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5605 _call_mock_process_numa_memory
[0].args
,
5607 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5609 {"hw:numa_nodes": "2"},
5613 _call_mock_process_numa_memory
[1].args
,
5615 {"id": 1, "memory": 2, "vcpu": [2]},
5617 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5620 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5622 _call_mock_process_numa_vcpu
[0].args
,
5624 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5626 {"hw:numa_nodes": "2"},
5630 _call_mock_process_numa_vcpu
[1].args
,
5632 {"id": 1, "memory": 2, "vcpu": [2]},
5634 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5637 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5638 self
.check_if_assert_not_called(
5640 mock_process_numa_threads
,
5641 mock_process_numa_cores
,
5642 mock_process_numa_paired_threads
,
5646 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5647 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5648 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5651 "process_numa_paired_threads",
5652 new_callable
=CopyingMock(),
5654 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5655 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5656 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_openstack_extra_spec_not_empty(
5658 mock_process_numa_threads
,
5659 mock_process_numa_cores
,
5660 mock_process_numa_paired_threads
,
5661 mock_process_numa_vcpu
,
5662 mock_process_numa_memory
,
5663 mock_process_vio_numa_nodes
,
5665 """Process numa parameters, id, paired-threads exist, vim type is openstack.
5666 vcpus calculation according to paired-threads in numa, there is extra_spec.
5668 numas
= [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
5669 extra_specs
= {"some-key": "some-value"}
5670 expected_extra_specs
= {
5671 "hw:cpu_sockets": "2",
5672 "hw:cpu_threads": "12",
5673 "hw:numa_nodes": "2",
5674 "some-key": "some-value",
5676 self
.vimconn
.vim_type
= "openstack"
5677 mock_process_numa_paired_threads
.side_effect
= [6, 6]
5678 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5680 self
.check_if_assert_not_called(
5681 [mock_process_numa_threads
, mock_process_numa_cores
]
5683 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5684 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5685 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5686 _call_mock_process_numa_paired_threads
= (
5687 mock_process_numa_paired_threads
.call_args_list
5690 _call_mock_process_numa_paired_threads
[0].args
,
5692 {"id": 0, "paired-threads": 3},
5693 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5697 _call_mock_process_numa_paired_threads
[1].args
,
5699 {"id": 1, "paired-threads": 3},
5700 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5703 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5705 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5706 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5707 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5710 "process_numa_paired_threads",
5711 new_callable
=CopyingMock(),
5713 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5714 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5715 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_vio_extra_spec_not_empty(
5717 mock_process_numa_threads
,
5718 mock_process_numa_cores
,
5719 mock_process_numa_paired_threads
,
5720 mock_process_numa_vcpu
,
5721 mock_process_numa_memory
,
5722 mock_process_vio_numa_nodes
,
5724 """Process numa parameters, id, paired-threads exist, vim type is VIO.
5725 vcpus calculation according to paired-threads in numa, there is extra_spec.
5727 numas
= [{"id": 0, "paired-threads": 2}, {"id": 1, "paired-threads": 2}]
5728 extra_specs
= {"some-key": "some-value"}
5729 expected_extra_specs
= {
5730 "hw:numa_nodes": "2",
5731 "hw:cpu_sockets": "2",
5732 "hw:cpu_threads": "8",
5733 "some-key": "some-value",
5735 self
.vimconn
.vim_type
= "VIO"
5736 mock_process_numa_paired_threads
.side_effect
= [4, 4]
5737 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5738 self
.check_if_assert_not_called(
5739 [mock_process_numa_threads
, mock_process_numa_cores
]
5741 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5742 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5743 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5744 _call_mock_process_numa_paired_threads
= (
5745 mock_process_numa_paired_threads
.call_args_list
5747 mock_process_vio_numa_nodes
.assert_called_once_with(
5748 2, {"some-key": "some-value", "hw:numa_nodes": "2"}
5751 _call_mock_process_numa_paired_threads
[0].args
,
5753 {"id": 0, "paired-threads": 2},
5755 "hw:cpu_sockets": "2",
5756 "hw:numa_nodes": "2",
5757 "some-key": "some-value",
5762 _call_mock_process_numa_paired_threads
[1].args
,
5764 {"id": 1, "paired-threads": 2},
5766 "hw:cpu_sockets": "2",
5767 "hw:numa_nodes": "2",
5768 "some-key": "some-value",
5772 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5774 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5775 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5776 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5779 "process_numa_paired_threads",
5780 new_callable
=CopyingMock(),
5782 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5783 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5784 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_openstack(
5786 mock_process_numa_threads
,
5787 mock_process_numa_cores
,
5788 mock_process_numa_paired_threads
,
5789 mock_process_numa_vcpu
,
5790 mock_process_numa_memory
,
5791 mock_process_vio_numa_nodes
,
5793 """Process numa parameters, id, cores exist, vim type is openstack.
5794 vcpus calculation according to cores in numa.
5796 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5798 updated_extra_specs
= {"hw:numa_nodes": "2", "hw:cpu_sockets": "2"}
5799 expected_extra_specs
= {
5800 "hw:numa_nodes": "2",
5801 "hw:cpu_sockets": "2",
5802 "hw:cpu_cores": "3",
5804 self
.vimconn
.vim_type
= "openstack"
5805 mock_process_numa_cores
.side_effect
= [1, 2]
5806 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5808 self
.check_if_assert_not_called(
5809 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5811 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5812 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5813 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5814 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5816 _call_mock_process_numa_cores
[0].args
,
5817 ({"id": 0, "cores": 1}, updated_extra_specs
),
5820 _call_mock_process_numa_cores
[1].args
,
5821 ({"id": 1, "cores": 2}, updated_extra_specs
),
5823 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5825 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5826 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5827 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5830 "process_numa_paired_threads",
5831 new_callable
=CopyingMock(),
5833 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5834 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5835 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_vio(
5837 mock_process_numa_threads
,
5838 mock_process_numa_cores
,
5839 mock_process_numa_paired_threads
,
5840 mock_process_numa_vcpu
,
5841 mock_process_numa_memory
,
5842 mock_process_vio_numa_nodes
,
5844 """Process numa parameters, id, cores exist, vim type is VIO.
5845 vcpus calculation according to cores in numa.
5847 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5849 expected_extra_specs
= {
5850 "hw:cpu_cores": "3",
5851 "hw:cpu_sockets": "2",
5852 "hw:numa_nodes": "2",
5854 self
.vimconn
.vim_type
= "VIO"
5855 mock_process_numa_cores
.side_effect
= [1, 2]
5856 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5857 self
.check_if_assert_not_called(
5858 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5860 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5861 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5862 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5863 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5864 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5866 _call_mock_process_numa_cores
[0].args
,
5868 {"id": 0, "cores": 1},
5870 "hw:cpu_sockets": "2",
5871 "hw:numa_nodes": "2",
5876 _call_mock_process_numa_cores
[1].args
,
5878 {"id": 1, "cores": 2},
5880 "hw:cpu_sockets": "2",
5881 "hw:numa_nodes": "2",
5885 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5887 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5888 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5889 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5892 "process_numa_paired_threads",
5893 new_callable
=CopyingMock(),
5895 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5896 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5897 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_vio(
5899 mock_process_numa_threads
,
5900 mock_process_numa_cores
,
5901 mock_process_numa_paired_threads
,
5902 mock_process_numa_vcpu
,
5903 mock_process_numa_memory
,
5904 mock_process_vio_numa_nodes
,
5906 """Process numa parameters, memory, vcpu, thread exist, vim type is VIO,
5907 vcpus calculation according threads in numa, there are not numa ids.
5910 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5911 {"memory": 2, "vcpu": [2]},
5914 expected_extra_specs
= {
5915 "hw:numa_nodes": "2",
5916 "hw:cpu_sockets": "2",
5917 "hw:cpu_threads": "3",
5919 self
.vimconn
.vim_type
= "VIO"
5920 mock_process_numa_threads
.return_value
= 3
5921 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5922 self
.check_if_assert_not_called(
5924 mock_process_numa_memory
,
5925 mock_process_numa_vcpu
,
5926 mock_process_numa_cores
,
5927 mock_process_numa_paired_threads
,
5930 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5931 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5932 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5934 _call_mock_process_numa_threads
[0].args
,
5936 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5938 "hw:cpu_sockets": "2",
5939 "hw:numa_nodes": "2",
5943 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5945 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5946 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5947 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5950 "process_numa_paired_threads",
5951 new_callable
=CopyingMock(autospec
=True),
5953 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5954 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5955 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_openstack(
5957 mock_process_numa_threads
,
5958 mock_process_numa_cores
,
5959 mock_process_numa_paired_threads
,
5960 mock_process_numa_vcpu
,
5961 mock_process_numa_memory
,
5962 mock_process_vio_numa_nodes
,
5964 """Process numa parameters, memory, vcpu, thread exist, vim type is openstack,
5965 vcpus calculation according threads in numa, there are not numa ids.
5968 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5969 {"memory": 2, "vcpu": [2]},
5972 expected_extra_specs
= {
5973 "hw:numa_nodes": "2",
5974 "hw:cpu_sockets": "2",
5975 "hw:cpu_threads": "3",
5977 self
.vimconn
.vim_type
= "openstack"
5978 mock_process_numa_threads
.return_value
= 3
5979 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5981 self
.check_if_assert_not_called(
5983 mock_process_numa_memory
,
5984 mock_process_numa_vcpu
,
5985 mock_process_numa_cores
,
5986 mock_process_numa_paired_threads
,
5987 mock_process_vio_numa_nodes
,
5990 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
5991 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
5993 _call_mock_process_numa_threads
[0].args
,
5995 {"memory": 1, "vcpu": [1, 3], "threads": 3},
5996 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5999 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
6001 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
6002 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
6003 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
6006 "process_numa_paired_threads",
6007 new_callable
=CopyingMock(),
6009 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
6010 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
6011 def test_process_numa_parameters_of_flavor_empty_numas_list_type_vio(
6013 mock_process_numa_threads
,
6014 mock_process_numa_cores
,
6015 mock_process_numa_paired_threads
,
6016 mock_process_numa_vcpu
,
6017 mock_process_numa_memory
,
6018 mock_process_vio_numa_nodes
,
6020 """Numa list is empty, vim type is VIO."""
6023 expected_extra_specs
= {"hw:numa_nodes": "0"}
6024 self
.vimconn
.vim_type
= "VIO"
6025 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
6026 self
.check_if_assert_not_called(
6028 mock_process_numa_memory
,
6029 mock_process_numa_vcpu
,
6030 mock_process_numa_cores
,
6031 mock_process_numa_paired_threads
,
6032 mock_process_numa_threads
,
6035 mock_process_vio_numa_nodes
.assert_called_once_with(0, {"hw:numa_nodes": "0"})
6036 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
6038 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
6039 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
6040 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
6043 "process_numa_paired_threads",
6044 new_callable
=CopyingMock(),
6046 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
6047 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
6048 def test_process_numa_parameters_of_flavor_empty_numas_list_type_openstack(
6050 mock_process_numa_threads
,
6051 mock_process_numa_cores
,
6052 mock_process_numa_paired_threads
,
6053 mock_process_numa_vcpu
,
6054 mock_process_numa_memory
,
6055 mock_process_vio_numa_nodes
,
6057 """Numa list is empty, vim type is openstack."""
6060 expected_extra_specs
= {"hw:numa_nodes": "0"}
6061 self
.vimconn
.vim_type
= "openstack"
6062 mock_process_numa_threads
.return_value
= None
6063 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
6065 self
.check_if_assert_not_called(
6067 mock_process_numa_memory
,
6068 mock_process_numa_vcpu
,
6069 mock_process_numa_cores
,
6070 mock_process_numa_paired_threads
,
6071 mock_process_numa_threads
,
6072 mock_process_vio_numa_nodes
,
6075 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
6077 def test_process_numa_memory_empty_extra_spec(self
):
6078 numa
= {"memory": 2, "vcpu": [2]}
6081 expected_extra_spec
= {"hw:numa_mem.2": 2048}
6082 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
6083 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6085 def test_process_numa_memory_not_exist(self
):
6086 numa
= {"vcpu": [2]}
6088 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
6089 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
6090 self
.assertDictEqual(extra_specs
, {"vmware:latency_sensitivity_level": "high"})
6092 def test_process_numa_memory_node_id_is_none(self
):
6093 numa
= {"memory": 2, "vcpu": [2]}
6096 expected_extra_spec
= {"hw:numa_mem.None": 2048}
6097 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
6098 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6100 def test_process_numa_vcpu_empty_extra_spec(self
):
6101 numa
= {"vcpu": [2]}
6104 expected_extra_spec
= {"hw:numa_cpus.0": "2"}
6105 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6106 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6108 def test_process_numa_vcpu_not_exist(self
):
6109 numa
= {"memory": 2}
6111 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
6112 expected_extra_spec
= {"vmware:latency_sensitivity_level": "high"}
6113 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6114 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6116 def test_process_numa_vcpu_empty_node_id(self
):
6117 numa
= {"vcpu": [2]}
6120 expected_extra_spec
= {"hw:numa_cpus.": "2"}
6121 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6122 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6124 def test_process_numa_vcpu_empty_numa_dict(self
):
6128 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6129 self
.assertDictEqual(extra_specs
, {})
6131 def test_process_numa_vcpu_str_node_id(self
):
6132 numa
= {"vcpu": [2]}
6135 expected_extra_spec
= {"hw:numa_cpus.12": "2"}
6136 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6137 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6139 def test_process_numa_paired_threads_empty_extra_spec(self
):
6140 numa
= {"id": 0, "paired-threads": 3}
6142 expected_extra_spec
= {
6143 "hw:cpu_thread_policy": "require",
6144 "hw:cpu_policy": "dedicated",
6146 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6147 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6148 self
.assertEqual(result
, 6)
6150 def test_process_numa_paired_threads_empty_numa(self
):
6153 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6154 self
.assertDictEqual(extra_specs
, {})
6155 self
.assertEqual(result
, None)
6157 def test_process_numa_paired_threads_not_exist(self
):
6158 numa
= {"vcpu": [2]}
6160 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6161 self
.assertDictEqual(extra_specs
, {})
6162 self
.assertEqual(result
, None)
6164 def test_process_numa_paired_threads_str_thread_num(self
):
6165 numa
= {"id": 0, "paired-threads": "3"}
6167 expected_extra_spec
= {
6168 "hw:cpu_thread_policy": "require",
6169 "hw:cpu_policy": "dedicated",
6171 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6172 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6173 self
.assertEqual(result
, "33")
6175 def test_process_numa_paired_threads_none_thread_num(self
):
6176 numa
= {"id": 0, "paired-threads": None}
6178 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6179 self
.assertDictEqual(extra_specs
, {})
6180 self
.assertEqual(result
, None)
6182 def test_process_numa_cores_empty_extra_spec(self
):
6183 numa
= {"id": 0, "cores": 1}
6185 expected_extra_spec
= {
6186 "hw:cpu_policy": "dedicated",
6187 "hw:cpu_thread_policy": "isolate",
6189 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6190 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6191 self
.assertEqual(result
, 1)
6193 def test_process_numa_cores_not_exist(self
):
6194 numa
= {"id": 0, "paired-threads": 3}
6196 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6197 self
.assertDictEqual(extra_specs
, {})
6198 self
.assertEqual(result
, None)
6200 def test_process_numa_cores_empty_numa(self
):
6202 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
6203 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6204 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6205 self
.assertEqual(result
, None)
6207 def test_process_numa_cores_none_core_num(self
):
6208 numa
= {"memory": 1, "cores": None}
6210 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6211 self
.assertDictEqual(extra_specs
, {})
6212 self
.assertEqual(result
, None)
6214 def test_process_numa_cores_string_core_num(self
):
6215 numa
= {"id": 0, "cores": "1"}
6216 extra_specs
= {"some-key": "some-val"}
6217 expected_extra_spec
= {
6218 "hw:cpu_policy": "dedicated",
6219 "hw:cpu_thread_policy": "isolate",
6220 "some-key": "some-val",
6222 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6223 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6224 self
.assertEqual(result
, "1")
6226 def test_process_numa_cores_float_core_num(self
):
6227 numa
= {"memory": 2, "cores": 10.03}
6228 extra_specs
= {"some-key": "some-val"}
6229 expected_extra_spec
= {
6230 "hw:cpu_policy": "dedicated",
6231 "hw:cpu_thread_policy": "isolate",
6232 "some-key": "some-val",
6234 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6235 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6236 self
.assertEqual(result
, 10.03)
6238 def test_process_numa_threads_empty_extra_spec_int_thread_num(self
):
6239 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3}
6241 expected_extra_spec
= {
6242 "hw:cpu_policy": "dedicated",
6243 "hw:cpu_thread_policy": "prefer",
6245 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6246 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6247 self
.assertEqual(result
, 3)
6249 def test_process_numa_threads_empty_numa(self
):
6251 extra_specs
= {"some-key": "some-val"}
6252 expected_extra_spec
= {"some-key": "some-val"}
6253 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6254 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6255 self
.assertEqual(result
, None)
6257 def test_process_numa_threads_not_exist(self
):
6258 numa
= {"memory": 1}
6259 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
6260 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6261 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6262 self
.assertEqual(result
, None)
6264 def test_process_numa_threads_str_thread_num(self
):
6265 numa
= {"vcpu": [1, 3], "threads": "3"}
6267 expected_extra_spec
= {
6268 "hw:cpu_policy": "dedicated",
6269 "hw:cpu_thread_policy": "prefer",
6271 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6272 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6273 self
.assertEqual(result
, "3")
6275 def test_process_numa_threads_none_thread_num(self
):
6276 numa
= {"vcpu": [1, 3], "threads": None}
6278 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6279 self
.assertDictEqual(extra_specs
, {})
6280 self
.assertEqual(result
, None)
6282 def test_process_numa_threads_float_thread_num(self
):
6283 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3.3}
6284 extra_specs
= {"some-key": "some-val"}
6285 expected_extra_spec
= {
6286 "hw:cpu_policy": "dedicated",
6287 "hw:cpu_thread_policy": "prefer",
6288 "some-key": "some-val",
6290 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6291 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6292 self
.assertEqual(result
, 3.3)
6294 def test_change_the_flavor_name_not_existing_name(self
):
6295 """Flavor name does not exist in Openstack flavor list."""
6296 self
.flavor1
.name
= "sample-flavor-3"
6297 self
.flavor2
.name
= "other-flavor-4"
6298 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6299 name
= "other-flavor-3"
6301 flavor_data
= {"name": "other-flavor"}
6302 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6303 self
.assertEqual(result
, name
)
6304 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6305 # Checking whether name_suffix changed or not.
6306 self
.assertEqual(name_suffix
, 3)
6308 def test_change_the_flavor_name_existing_name(self
):
6309 """Flavor name exists in Openstack flavor list."""
6310 self
.flavor1
.name
= "other-flavor-6"
6311 self
.flavor2
.name
= "other-flavor-3"
6312 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6313 name
= "other-flavor-3"
6315 flavor_data
= {"name": "other-flavor"}
6316 expected_result
= "other-flavor-7"
6317 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6318 self
.assertEqual(result
, expected_result
)
6319 # Checking whether name_suffix changed or not.
6320 self
.assertEqual(name_suffix
, 5)
6321 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6323 def test_change_the_flavor_name_flavor_data_does_not_have_name(self
):
6324 """Flavor data does not have name."""
6325 self
.flavor1
.name
= "other-flavor-6"
6326 self
.flavor2
.name
= "other-flavor-3"
6327 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6328 name
= "other-flavor-3"
6331 with self
.assertRaises(KeyError):
6332 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6333 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6334 # Checking whether name_suffix changed or not.
6335 self
.assertEqual(name_suffix
, 5)
6337 def test_change_the_flavor_name_invalid_name_suffix(self
):
6338 """Name suffix is invalid."""
6339 self
.flavor1
.name
= "other-flavor-6"
6340 self
.flavor2
.name
= "other-flavor-3"
6341 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6342 name
= "other-flavor-3"
6344 flavor_data
= {"name": "other-flavor"}
6345 with self
.assertRaises(TypeError):
6346 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6347 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6348 # Checking whether name_suffix changed or not.
6349 self
.assertEqual(name_suffix
, "a")
6351 def test_change_the_flavor_name_given_name_is_empty(self
):
6352 """Given name is empty string."""
6353 self
.flavor1
.name
= "other-flavor-6"
6354 self
.flavor2
.name
= "other-flavor-3"
6355 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6358 flavor_data
= {"name": "other-flavor"}
6359 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6360 self
.assertEqual(result
, "")
6361 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6362 # Checking whether name_suffix increased or not.
6363 self
.assertEqual(name_suffix
, 3)
6365 def test_change_the_flavor_name_given_name_is_none(self
):
6366 """Given name is None."""
6367 self
.flavor1
.name
= "other-flavor-6"
6368 self
.flavor2
.name
= "other-flavor-3"
6369 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6372 flavor_data
= {"name": "other-flavor"}
6373 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6374 self
.assertEqual(result
, None)
6375 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6376 # Checking whether name_suffix increased or not.
6377 self
.assertEqual(name_suffix
, 6)
6379 def test_change_the_flavor_name_empty_nova_flavor_list(self
):
6380 """Nova flavor list is empty."""
6381 self
.vimconn
.nova
.flavors
.list.return_value
= []
6382 name
= "other-flavor-3"
6384 flavor_data
= {"name": "other-flavor"}
6385 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6386 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6387 self
.assertEqual(result
, name
)
6388 # Checking whether name_suffix increased or not.
6389 self
.assertEqual(name_suffix
, 5)
6393 "_process_numa_parameters_of_flavor",
6394 new_callable
=CopyingMock(),
6396 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6397 def test_process_extended_config_of_flavor_with_numa_cpu_mem_vif_disk_quota(
6398 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6400 """Process extended config, extended has numas, cpu, mem, vif and disk-io quota."""
6402 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6403 {"memory": 2, "vcpu": [2]},
6407 "cpu-quota": {"limit": 3},
6408 "mem-quota": {"limit": 1},
6409 "vif-quota": {"limit": 10},
6410 "disk-io-quota": {"limit": 50},
6411 "mempage-size": "LARGE",
6414 expected_extra_specs
= {
6415 "hw:mem_page_size": "large",
6417 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6419 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6420 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6421 self
.assertEqual(extra_specs
, expected_extra_specs
)
6425 "_process_numa_parameters_of_flavor",
6426 new_callable
=CopyingMock(),
6428 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6429 def test_process_extended_config_of_flavor_with_numa_wrong_disk_quota(
6430 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6432 """Process extended config, extended has wrong disk quota key."""
6434 {"memory": 1, "threads": 3},
6435 {"memory": 2, "vcpu": [2]},
6439 "disk-quota": {"limit": 50},
6440 "mempage-size": "PREFER_LARGE",
6443 expected_extra_specs
= {
6444 "hw:mem_page_size": "any",
6446 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6447 mock_process_resource_quota
.assert_not_called()
6448 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6449 self
.assertEqual(extra_specs
, expected_extra_specs
)
6453 "_process_numa_parameters_of_flavor",
6454 new_callable
=CopyingMock(),
6456 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6457 def test_process_extended_config_of_flavor_without_numa_cpu_mem_vif_disk_quota(
6458 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6460 """Process extended config, extended has cpu, mem, vif and disk-io quota but not numas."""
6462 "cpu-quota": {"limit": 3},
6463 "mem-quota": {"limit": 1},
6464 "vif-quota": {"limit": 10},
6465 "disk-io-quota": {"limit": 50},
6466 "mempage-size": "SMALL",
6469 expected_extra_specs
= {
6470 "hw:mem_page_size": "small",
6472 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6473 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6474 mock_process_numa_parameters_of_flavor
.assert_not_called()
6475 self
.assertEqual(extra_specs
, expected_extra_specs
)
6479 "_process_numa_parameters_of_flavor",
6480 new_callable
=CopyingMock(),
6482 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6483 def test_process_extended_config_of_flavor_with_numa_with_cpu_pinning_mem_policy(
6484 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6486 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy."""
6489 {"memory": 2, "vcpu": [2]},
6493 "cpu-quota": {"limit": 3},
6494 "mem-quota": {"limit": 1},
6495 "mempage-size": "LARGE",
6496 "cpu-pinning-policy": "DEDICATED",
6497 "mem-policy": "STRICT",
6500 expected_extra_specs
= {
6501 "hw:mem_page_size": "large",
6502 "hw:cpu_policy": "dedicated",
6503 "hw:numa_mempolicy": "strict",
6505 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6506 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6507 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6508 self
.assertEqual(extra_specs
, expected_extra_specs
)
6512 "_process_numa_parameters_of_flavor",
6513 new_callable
=CopyingMock(),
6515 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6516 def test_process_extended_config_of_flavor_without_numa_with_cpu_pinning_mem_policy(
6517 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6519 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy but not numas."""
6521 "cpu-quota": {"limit": 3},
6522 "mem-quota": {"limit": 1},
6523 "mempage-size": "LARGE",
6524 "cpu-pinning-policy": "DEDICATED",
6525 "mem-policy": "STRICT",
6528 expected_extra_specs
= {
6529 "hw:mem_page_size": "large",
6530 "hw:cpu_policy": "dedicated",
6531 "hw:numa_mempolicy": "strict",
6533 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6534 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6535 mock_process_numa_parameters_of_flavor
.assert_not_called()
6536 self
.assertEqual(extra_specs
, expected_extra_specs
)
6540 "_process_numa_parameters_of_flavor",
6541 new_callable
=CopyingMock(),
6543 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6544 def test_process_extended_config_of_flavor_without_numa_with_wrong_mempage_size(
6545 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6547 """Process extended config, extended has wrong mempage-size without numas."""
6549 "cpu-quota": {"limit": 3},
6550 "mem-quota": {"limit": 1},
6551 "mempage-size": "SIZE_2GB",
6552 "cpu-pinning-policy": "DEDICATED",
6553 "mem-policy": "STRICT",
6557 expected_extra_specs
= {
6558 "hw:cpu_policy": "dedicated",
6559 "hw:numa_mempolicy": "strict",
6561 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6562 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6563 mock_process_numa_parameters_of_flavor
.assert_not_called()
6564 self
.assertEqual(extra_specs
, expected_extra_specs
)
6568 "_process_numa_parameters_of_flavor",
6569 new_callable
=CopyingMock(),
6571 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6572 def test_process_extended_config_of_flavor_with_numa_with_wrong_mempage_size(
6573 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6575 """Process extended config, extended has wrong mempage-size with numas."""
6578 {"memory": 2, "vcpu": [2]},
6582 "cpu-quota": {"limit": 3},
6583 "mem-quota": {"limit": 1},
6584 "mempage-size": "SIZE_2GB",
6585 "cpu-pinning-policy": "DEDICATED",
6586 "mem-policy": "STRICT",
6589 expected_extra_specs
= {
6590 "hw:cpu_policy": "dedicated",
6591 "hw:numa_mempolicy": "strict",
6593 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6594 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6595 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6596 self
.assertEqual(extra_specs
, expected_extra_specs
)
6600 "_process_numa_parameters_of_flavor",
6601 new_callable
=CopyingMock(),
6603 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6604 def test_process_extended_config_of_flavor_none_vcpus(
6605 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6607 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6610 {"memory": 2, "vcpu": [2]},
6614 "cpu-quota": {"limit": 3},
6615 "mem-quota": {"limit": 1},
6616 "mempage-size": "SIZE_2GB",
6617 "cpu-pinning-policy": "DEDICATED",
6618 "mem-policy": "STRICT",
6621 expected_extra_specs
= {
6622 "hw:cpu_policy": "dedicated",
6623 "hw:numa_mempolicy": "strict",
6625 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6626 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6627 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6628 self
.assertEqual(extra_specs
, expected_extra_specs
)
6632 "_process_numa_parameters_of_flavor",
6633 new_callable
=CopyingMock(),
6635 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6636 def test_process_extended_config_of_flavor_none_vcpus_without_numas(
6637 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6639 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6641 "cpu-quota": {"limit": 3},
6642 "mem-quota": {"limit": 1},
6643 "mempage-size": "SIZE_2GB",
6644 "cpu-pinning-policy": "DEDICATED",
6645 "mem-policy": "STRICT",
6647 extra_specs
= {"some-key": "some-val"}
6648 expected_extra_specs
= {
6649 "hw:cpu_policy": "dedicated",
6650 "hw:numa_mempolicy": "strict",
6651 "some-key": "some-val",
6653 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6654 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6655 mock_process_numa_parameters_of_flavor
.assert_not_called()
6656 self
.assertEqual(extra_specs
, expected_extra_specs
)
6660 "_process_numa_parameters_of_flavor",
6661 new_callable
=CopyingMock(),
6663 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6664 def test_process_extended_config_of_flavor_wrong_cpu_pinning_mem_policy_empty_vcpus(
6665 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6667 """Process extended config, extended has wrong cpu-pinning and mem-policy keys."""
6670 {"memory": 2, "vcpu": [2]},
6674 "cpu-quota": {"limit": 3},
6675 "mem-quota": {"limit": 1},
6676 "mempage-size": "SIZE_2GB",
6677 "cpu-pinning-pol": "DEDICATED",
6678 "mem-pol": "STRICT",
6681 expected_extra_specs
= {}
6682 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6683 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6684 mock_process_numa_parameters_of_flavor
.assert_called_once_with(
6687 self
.assertEqual(extra_specs
, expected_extra_specs
)
6691 "_process_numa_parameters_of_flavor",
6692 new_callable
=CopyingMock(),
6694 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6695 def test_process_extended_config_of_flavor_empty_extended(
6696 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6698 """Process extended config, extended is empty."""
6701 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6702 self
.check_if_assert_not_called(
6703 [mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
]
6705 self
.assertEqual(extra_specs
, {})
6707 def test_get_flavor_details_empty_flavor_data(self
):
6709 expected_result
= (64, 1, {}, None)
6710 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6711 self
.assertEqual(result
, expected_result
)
6713 def test_get_flavor_details_flavor_data_has_ram_vcpus_extended(self
):
6718 "some-key": "some-val",
6721 expected_result
= (32, 3, {}, {"some-key": "some-val"})
6722 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6723 self
.assertEqual(result
, expected_result
)
6725 def test_get_flavor_details_flavor_data_is_none(self
):
6727 with self
.assertRaises(AttributeError):
6728 self
.vimconn
._get
_flavor
_details
(flavor_data
)
6730 def test_get_flavor_details_flavor_data_has_only_extended(self
):
6733 "some-key": "some-val",
6736 expected_result
= (64, 1, {}, {"some-key": "some-val"})
6737 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6738 self
.assertEqual(result
, expected_result
)
6740 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6743 "_process_extended_config_of_flavor",
6744 new_callable
=CopyingMock(),
6746 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6747 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6748 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6749 def test_new_flavor_with_extended_with_extra_specs(
6751 mock_format_exception
,
6752 mock_reload_connection
,
6753 mock_change_flavor_name
,
6754 mock_extended_config_of_flavor
,
6755 mock_get_flavor_details
,
6757 """Create new flavor with using extended parameters and extra specs."""
6760 mock_change_flavor_name
.return_value
= name1
6761 mock_get_flavor_details
.return_value
= (
6764 {"some-key": "some-value"},
6767 expected_result
= self
.new_flavor
.id
6768 result
= self
.vimconn
.new_flavor(flavor_data
)
6769 self
.assertEqual(result
, expected_result
)
6770 mock_reload_connection
.assert_called_once()
6771 self
.new_flavor
.set_keys
.assert_called_once()
6772 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6773 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6774 mock_extended_config_of_flavor
.assert_called_once_with(
6775 extended
, {"some-key": "some-value"}
6777 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6778 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6780 mock_format_exception
.assert_not_called()
6782 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6785 "_process_extended_config_of_flavor",
6786 new_callable
=CopyingMock(),
6788 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6789 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6790 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6791 def test_new_flavor_with_extended_without_extra_specs(
6793 mock_format_exception
,
6794 mock_reload_connection
,
6795 mock_change_flavor_name
,
6796 mock_extended_config_of_flavor
,
6797 mock_get_flavor_details
,
6799 """Create new flavor with using extended parameters without extra specs."""
6802 mock_change_flavor_name
.return_value
= name1
6803 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6804 expected_result
= self
.new_flavor
.id
6805 result
= self
.vimconn
.new_flavor(flavor_data
)
6806 self
.assertEqual(result
, expected_result
)
6807 mock_reload_connection
.assert_called_once()
6808 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6809 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6810 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6811 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6812 name
=name1
, ram
=3, vcpus
=vcpus
, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6814 self
.check_if_assert_not_called(
6815 [self
.new_flavor
.set_keys
, mock_format_exception
]
6818 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6821 "_process_extended_config_of_flavor",
6822 new_callable
=CopyingMock(),
6824 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6825 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6826 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6827 def test_new_flavor_change_name_if_used_false_with_extended(
6829 mock_format_exception
,
6830 mock_reload_connection
,
6831 mock_change_flavor_name
,
6832 mock_extended_config_of_flavor
,
6833 mock_get_flavor_details
,
6835 """Create new flavor, change_name_if_used_false, there is extended."""
6837 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6838 expected_result
= self
.new_flavor
.id
6839 result
= self
.vimconn
.new_flavor(flavor_data
, False)
6840 self
.assertEqual(result
, expected_result
)
6841 mock_reload_connection
.assert_called_once()
6842 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6843 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6844 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6845 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6847 self
.check_if_assert_not_called(
6848 [mock_change_flavor_name
, mock_format_exception
, self
.new_flavor
.set_keys
]
6851 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6854 "_process_extended_config_of_flavor",
6855 new_callable
=CopyingMock(),
6857 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6858 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6859 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6860 def test_new_flavor_change_name_if_used_true_without_extended(
6862 mock_format_exception
,
6863 mock_reload_connection
,
6864 mock_change_flavor_name
,
6865 mock_extended_config_of_flavor
,
6866 mock_get_flavor_details
,
6868 """Create new flavor without extended parameters."""
6870 mock_change_flavor_name
.return_value
= name1
6871 expected_result
= self
.new_flavor
.id
6872 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6873 result
= self
.vimconn
.new_flavor(flavor_data2
)
6874 self
.assertEqual(result
, expected_result
)
6875 mock_reload_connection
.assert_called_once()
6876 mock_change_flavor_name
.assert_called_once_with(
6877 name1
, name_suffix
, flavor_data2
6879 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6880 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6881 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6883 self
.check_if_assert_not_called(
6885 self
.new_flavor
.set_keys
,
6886 mock_extended_config_of_flavor
,
6887 mock_format_exception
,
6891 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6894 "_process_extended_config_of_flavor",
6895 new_callable
=CopyingMock(),
6897 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6898 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6899 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6900 def test_new_flavor_reload_connection_exception(
6902 mock_format_exception
,
6903 mock_reload_connection
,
6904 mock_change_flavor_name
,
6905 mock_extended_config_of_flavor
,
6906 mock_get_flavor_details
,
6908 """Create new flavor, reload connection exception occurred."""
6909 error_msg
= "Can not connect to client APIs."
6910 error
= nvExceptions
.ClientException(error_msg
)
6911 mock_change_flavor_name
.return_value
= name1
6912 mock_reload_connection
.side_effect
= error
6913 with self
.assertRaises(Exception) as err
:
6914 self
.vimconn
.new_flavor(flavor_data2
)
6915 self
.assertEqual(str(err
.exception
), "Can not connect to client APIs.")
6916 self
.assertEqual(mock_reload_connection
.call_count
, 1)
6917 call_mock_format_exception
= mock_format_exception
.call_args
6919 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
6921 self
.check_if_assert_not_called(
6923 mock_change_flavor_name
,
6924 mock_get_flavor_details
,
6925 mock_extended_config_of_flavor
,
6926 self
.vimconn
.nova
.flavors
.create
,
6930 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6933 "_process_extended_config_of_flavor",
6934 new_callable
=CopyingMock(autospec
=True),
6936 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6937 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6938 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6939 def test_new_flavor_flavor_data_without_name(
6941 mock_format_exception
,
6942 mock_reload_connection
,
6943 mock_change_flavor_name
,
6944 mock_extended_config_of_flavor
,
6945 mock_get_flavor_details
,
6947 """Create new flavor, flavor data does not have name."""
6954 self
.vimconn
.new_flavor(flavor_data3
)
6955 mock_format_exception
.assert_called_once()
6956 call_mock_format_exception
= mock_format_exception
.call_args
6958 str(call_mock_format_exception
[0][0]), str(KeyError(error_msg
))
6960 self
.check_if_assert_not_called(
6962 mock_reload_connection
,
6963 mock_change_flavor_name
,
6964 mock_get_flavor_details
,
6965 mock_extended_config_of_flavor
,
6966 self
.vimconn
.nova
.flavors
.create
,
6970 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6973 "_process_extended_config_of_flavor",
6974 new_callable
=CopyingMock(),
6976 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6977 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6978 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6979 def test_new_flavor_change_flavor_name_has_extended_conflict_exception_recovered_in_retry(
6981 mock_format_exception
,
6982 mock_reload_connection
,
6983 mock_change_flavor_name
,
6984 mock_extended_config_of_flavor
,
6985 mock_get_flavor_details
,
6987 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is extended config."""
6989 error_msg
= "Conflict has occurred while creating flavor name."
6990 error2
= nvExceptions
.Conflict(error_msg
)
6991 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
6992 expected_result
= self
.new_flavor
.id
6993 mock_get_flavor_details
.return_value
= (3, 8, {}, extended
)
6994 result
= self
.vimconn
.new_flavor(flavor_data2
)
6995 self
.assertEqual(result
, expected_result
)
6996 self
.assertEqual(mock_reload_connection
.call_count
, 2)
6997 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
6998 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
6999 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
7000 self
.assertEqual(mock_extended_config_of_flavor
.call_count
, 1)
7001 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
7002 name
="sample-flavor-3",
7010 self
.check_if_assert_not_called(
7011 [self
.new_flavor
.set_keys
, mock_format_exception
]
7014 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7017 "_process_extended_config_of_flavor",
7018 new_callable
=CopyingMock(),
7020 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7021 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7022 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7023 def test_new_flavor_change_flavor_name_without_extended_conflict_exception_recovered_in_retry(
7025 mock_format_exception
,
7026 mock_reload_connection
,
7027 mock_change_flavor_name
,
7028 mock_extended_config_of_flavor
,
7029 mock_get_flavor_details
,
7031 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is not extended config."""
7033 error2
= nvExceptions
.Conflict(
7034 "Conflict has occurred while creating flavor name."
7036 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
7037 expected_result
= self
.new_flavor
.id
7038 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
7039 result
= self
.vimconn
.new_flavor(flavor_data2
)
7040 self
.assertEqual(result
, expected_result
)
7041 self
.assertEqual(mock_reload_connection
.call_count
, 2)
7042 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
7043 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
7044 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
7045 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
7046 name
="sample-flavor-3",
7054 self
.check_if_assert_not_called(
7056 self
.new_flavor
.set_keys
,
7057 mock_extended_config_of_flavor
,
7058 mock_format_exception
,
7062 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7065 "_process_extended_config_of_flavor",
7066 new_callable
=CopyingMock(),
7068 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7069 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7070 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7071 def test_new_flavor_change_flavor_name_conflict_exception_change_name_if_used_false(
7073 mock_format_exception
,
7074 mock_reload_connection
,
7075 mock_change_flavor_name
,
7076 mock_extended_config_of_flavor
,
7077 mock_get_flavor_details
,
7079 """Create new flavor, nvExceptions.Conflict occurred,
7080 change_name_if_used is false."""
7081 change_name_if_used
= False
7082 error_msg
= "Conflict has occurred while creating flavor name."
7083 error2
= nvExceptions
.Conflict(error_msg
)
7084 mock_get_flavor_details
.return_value
= (4, 8, {}, None)
7085 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
7086 with self
.assertRaises(Exception) as err
:
7087 self
.vimconn
.new_flavor(flavor_data2
, change_name_if_used
)
7088 self
.assertEqual(str(err
.exception
), error_msg
)
7089 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
7090 self
.vimconn
.nova
.flavors
.create
.assert_called_with(
7091 name
="sample-flavor",
7099 self
.assertEqual(mock_get_flavor_details
.call_count
, 3)
7100 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
7101 self
.assertEqual(mock_reload_connection
.call_count
, 3)
7102 self
.check_if_assert_not_called(
7103 [mock_change_flavor_name
, mock_extended_config_of_flavor
]
7105 _call_mock_format_exception
= mock_format_exception
.call_args
7107 str(_call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
7109 self
.assertEqual(mock_format_exception
.call_count
, 3)
7111 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7114 "_process_extended_config_of_flavor",
7115 new_callable
=CopyingMock(),
7117 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7118 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7119 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7120 def test_new_flavor_client_exception_occurred_change_name_if_used_true(
7122 mock_format_exception
,
7123 mock_reload_connection
,
7124 mock_change_flavor_name
,
7125 mock_extended_config_of_flavor
,
7126 mock_get_flavor_details
,
7128 """Create new flavor, nvExceptions.ClientException occurred,
7129 change_name_if_used is true."""
7130 error_msg
= "Connection failed."
7131 error2
= nvExceptions
.ClientException(error_msg
)
7132 mock_change_flavor_name
.side_effect
= [
7137 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
7138 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
7139 with self
.assertRaises(Exception) as err
:
7140 self
.vimconn
.new_flavor(flavor_data2
)
7142 str(err
.exception
), "Conflict has occurred while creating flavor name."
7144 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
7145 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 1)
7146 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
7148 _call_mock_nova_create_flavor
[0][1],
7151 "name": "sample-flavor-3",
7162 self
.assertEqual(mock_reload_connection
.call_count
, 1)
7163 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
7164 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
7166 _call_mock_change_flavor
[0][0],
7170 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
7173 self
.assertEqual(mock_change_flavor_name
.call_count
, 1)
7174 mock_extended_config_of_flavor
.assert_not_called()
7175 call_mock_format_exception
= mock_format_exception
.call_args
7177 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
7179 self
.assertEqual(mock_format_exception
.call_count
, 1)
7181 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7184 "_process_extended_config_of_flavor",
7185 new_callable
=CopyingMock(),
7187 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7188 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7189 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7190 def test_new_flavor_change_flavor_name_conflict_exception_occurred_change_name_if_used_true(
7192 mock_format_exception
,
7193 mock_reload_connection
,
7194 mock_change_flavor_name
,
7195 mock_extended_config_of_flavor
,
7196 mock_get_flavor_details
,
7198 """Create new flavor, nvExceptions.Conflict occurred,
7199 change_name_if_used is true."""
7200 error_msg
= "Conflict has occurred while creating flavor name."
7201 error2
= nvExceptions
.Conflict(error_msg
)
7202 mock_change_flavor_name
.side_effect
= [
7207 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
7208 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
7209 with self
.assertRaises(Exception) as err
:
7210 self
.vimconn
.new_flavor(flavor_data2
)
7211 self
.assertEqual(str(err
.exception
), error_msg
)
7212 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
7213 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
7214 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
7216 _call_mock_nova_create_flavor
[0][1],
7219 "name": "sample-flavor-3",
7230 _call_mock_nova_create_flavor
[1][1],
7233 "name": "sample-flavor-4",
7244 _call_mock_nova_create_flavor
[2][1],
7247 "name": "sample-flavor-5",
7257 self
.assertEqual(mock_reload_connection
.call_count
, 3)
7258 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
7260 _call_mock_change_flavor
[0][0],
7264 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
7268 _call_mock_change_flavor
[1][0],
7272 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
7276 _call_mock_change_flavor
[2][0],
7280 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
7283 self
.assertEqual(mock_change_flavor_name
.call_count
, 3)
7284 mock_extended_config_of_flavor
.assert_not_called()
7285 call_mock_format_exception
= mock_format_exception
.call_args
7287 str(call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
7289 self
.assertEqual(mock_format_exception
.call_count
, 1)
7291 def test_process_process_vio_numa_nodes_without_numa_with_extra_spec(self
):
7293 extra_specs
= {"hw:numa_nodes": "0"}
7294 expected_extra_spec
= {
7295 "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
7296 "vmware:latency_sensitivity_level": "high",
7297 "hw:numa_nodes": "0",
7299 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7300 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
7302 def test_process_process_vio_numa_nodes_list_type_numa_nodes_empty_extra_spec(self
):
7303 numa_nodes
= [7, 9, 4]
7305 expected_extra_spec
= {
7306 "vmware:latency_sensitivity_level": "high",
7308 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7309 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
7311 def test_process_process_vio_numa_nodes_with_numa_with_extra_spec(self
):
7313 extra_specs
= {"hw:numa_nodes": "5"}
7314 expected_extra_spec
= {
7315 "vmware:latency_sensitivity_level": "high",
7316 "hw:numa_nodes": "5",
7318 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7319 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
7321 def test_process_process_vio_numa_nodes_none_numa_nodes(self
):
7323 extra_specs
= {"hw:numa_nodes": "None"}
7324 expected_extra_spec
= {
7325 "vmware:latency_sensitivity_level": "high",
7326 "hw:numa_nodes": "None",
7327 "vmware:extra_config": '{"numa.nodeAffinity":"0"}',
7329 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7330 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
7332 def test_process_process_vio_numa_nodes_invalid_type_extra_specs(self
):
7335 with self
.assertRaises(TypeError):
7336 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7339 if __name__
== "__main__":