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")
1130 def check_if_assert_not_called(mocks
: list):
1131 for mocking
in mocks
:
1132 mocking
.assert_not_called()
1136 def __init__(self
, s
):
1143 class CopyingMock(MagicMock
):
1144 def __call__(self
, *args
, **kwargs
):
1145 args
= deepcopy(args
)
1146 kwargs
= deepcopy(kwargs
)
1147 return super(CopyingMock
, self
).__call
__(*args
, **kwargs
)
1150 class TestNewVmInstance(unittest
.TestCase
):
1151 @patch("logging.getLogger", autospec
=True)
1152 def setUp(self
, mock_logger
):
1153 # Instantiate dummy VIM connector so we can test it
1154 # It throws exception because of dummy parameters,
1155 # We are disabling the logging of exception not to print them to console.
1156 mock_logger
= logging
.getLogger()
1157 mock_logger
.disabled
= True
1158 self
.vimconn
= vimconnector(
1168 self
.vimconn
.neutron
= CopyingMock()
1169 self
.vimconn
.nova
= CopyingMock()
1170 self
.vimconn
.cinder
= CopyingMock()
1171 self
.server
= MagicMock(object, autospec
=True)
1172 self
.server
.tenant_id
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
1173 self
.server
.id = "908b73-e9cc-5a6a-t270-82cc4811bd4a"
1174 self
.vimconn
.config
["security_groups"] = "default"
1175 self
.vimconn
.config
["keypair"] = "my_keypair"
1176 self
.vimconn
.security_groups_id
= "12345"
1177 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.32"
1178 self
.vimconn
.logger
= CopyingMock()
1180 @patch.object(vimconnector
, "_get_ids_from_name")
1181 def test_prepare_port_dict_security_security_groups_exists_in_config(
1184 """In VIM config security_groups exists, net port_security is True
1185 no_port_security_extension does not exist.
1187 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1188 net
= {"port_security": True}
1190 result_dict
= {"security_groups": "12345"}
1192 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1193 self
.assertDictEqual(result_dict
, port_dict
)
1194 mock_get_ids
.assert_not_called()
1196 @patch.object(vimconnector
, "_get_ids_from_name")
1197 def test_prepare_port_dict_security_security_groups_exists_in_config_no_security_groups_id(
1200 """In VIM config Security_groups exists, net port_security is True, vim security_groups_id does not exist,
1201 no_port_security_extension does not exist.
1203 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1204 self
.vimconn
.security_groups_id
= None
1205 net
= {"port_security": True}
1207 result_dict
= {"security_groups": None}
1209 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1210 self
.assertDictEqual(result_dict
, port_dict
)
1211 mock_get_ids
.assert_called()
1213 @patch.object(vimconnector
, "_get_ids_from_name")
1214 def test_prepare_port_dict_security_security_groups_exists_security_extension_true_in_config(
1217 """In VIM config security_groups exists, net port_security is True, in VIM security_groups_id exists,
1218 no_port_security_extension set to True.
1220 self
.vimconn
.config
= {
1221 "security_groups": "example_security_group",
1222 "no_port_security_extension": True,
1224 net
= {"port_security": True}
1228 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1229 self
.assertDictEqual(result_dict
, port_dict
)
1230 mock_get_ids
.assert_not_called()
1232 @patch.object(vimconnector
, "_get_ids_from_name")
1233 def test_prepare_port_dict_security_no_security_groups_in_config(
1236 """In VIM config security_group does not exist, net port_security True, in VIM security_groups_id exists,
1237 no_port_security_extension does not exist."""
1238 self
.vimconn
.config
= {}
1239 net
= {"port_security": True}
1243 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1244 self
.assertDictEqual(result_dict
, port_dict
)
1245 mock_get_ids
.assert_not_called()
1247 @patch.object(vimconnector
, "_get_ids_from_name")
1248 def test_prepare_port_dict_security_no_security_groups_security_extension_true_in_config(
1251 """Security_group does not exist, net port_security is True, in VIM security_groups_id exists,
1252 no_port_security_extension set to True."""
1253 self
.vimconn
.config
= {"no_port_security_extension": True}
1254 net
= {"port_security": True}
1258 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1259 self
.assertDictEqual(result_dict
, port_dict
)
1260 mock_get_ids
.assert_not_called()
1262 @patch.object(vimconnector
, "_get_ids_from_name")
1263 def test_prepare_port_dict_security_security_groups_exists_net_port_security_false(
1266 """In VIM config security_group exists, net port_security False, security_groups_id exists,
1267 no_port_security_extension does not exist."""
1268 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1269 net
= {"port_security": False}
1273 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1274 self
.assertDictEqual(result_dict
, port_dict
)
1275 mock_get_ids
.assert_not_called()
1277 @patch.object(vimconnector
, "_get_ids_from_name")
1278 def test_prepare_port_dict_security_net_port_security_false_port_security_extension_true(
1281 """In VIM config security_group exists, net port_security False, security_groups_id exists,
1282 no_port_security_extension set to True."""
1283 self
.vimconn
.config
= {
1284 "security_groups": "example_security_group",
1285 "no_port_security_extension": True,
1287 net
= {"port_security": False}
1291 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1292 self
.assertDictEqual(result_dict
, port_dict
)
1293 mock_get_ids
.assert_not_called()
1295 def test_prepare_port_dict_binding_net_type_virtual(self
):
1296 """net type is virtual."""
1297 net
= {"type": "virtual"}
1300 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1301 self
.assertDictEqual(result_dict
, port_dict
)
1303 def test_prepare_port_dict_binding_net_type_vf(self
):
1304 """net type is VF, vim_type is not VIO."""
1305 net
= {"type": "VF"}
1306 self
.vimconn
.vim_type
= None
1308 result_dict
= {"binding:vnic_type": "direct"}
1309 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1310 self
.assertDictEqual(port_dict
, result_dict
)
1312 def test_prepare_port_dict_binding_net_type_sriov_vim_type_vio(self
):
1313 """net type is SR-IOV, vim_type is VIO."""
1314 net
= {"type": "SR-IOV"}
1315 self
.vimconn
.vim_type
= "VIO"
1318 "binding:vnic_type": "direct",
1319 "port_security_enabled": False,
1320 "provider_security_groups": [],
1321 "security_groups": [],
1323 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1324 self
.assertDictEqual(port_dict
, result_dict
)
1326 def test_prepare_port_dict_binding_net_type_passthrough(self
):
1327 """net type is pci-passthrough."""
1328 net
= {"type": "PCI-PASSTHROUGH"}
1331 "binding:vnic_type": "direct-physical",
1333 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1334 self
.assertDictEqual(port_dict
, result_dict
)
1336 def test_prepare_port_dict_binding_no_net_type(self
):
1337 """net type is missing."""
1340 with self
.assertRaises(VimConnException
) as err
:
1341 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1342 self
.assertEqual(str(err
.exception
), "Type is missing in the network details.")
1344 def test_set_fixed_ip(self
):
1345 """new_port has fixed ip."""
1349 "fixed_ips": [{"ip_address": "10.1.2.3"}, {"ip_address": "20.1.2.3"}]
1352 result
= {"ip": "10.1.2.3"}
1353 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1354 self
.assertDictEqual(net
, result
)
1356 def test_set_fixed_ip_no_fixed_ip(self
):
1357 """new_port does not have fixed ip."""
1359 new_port
= {"port": {}}
1360 result
= {"ip": None}
1361 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1362 self
.assertDictEqual(net
, result
)
1364 def test_set_fixed_ip_raise_exception(self
):
1365 """new_port does not have port details."""
1368 with self
.assertRaises(Exception) as err
:
1369 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1370 self
.assertEqual(type(err
.exception
), KeyError)
1372 def test_prepare_port_dict_mac_ip_addr(self
):
1373 """mac address and ip address exist."""
1375 "mac_address": mac_address
,
1376 "ip_address": "10.0.1.5",
1380 "mac_address": mac_address
,
1381 "fixed_ips": [{"ip_address": "10.0.1.5"}],
1383 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
1384 self
.assertDictEqual(port_dict
, result_dict
)
1386 def test_prepare_port_dict_mac_ip_addr_no_mac_and_ip(self
):
1387 """mac address and ip address does not exist."""
1391 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
1392 self
.assertDictEqual(port_dict
, result_dict
)
1394 def test_create_new_port(self
):
1395 """new port has id and mac address."""
1399 "mac_address": mac_address
,
1402 self
.vimconn
.neutron
.create_port
.return_value
= new_port
1403 net
, port_dict
, created_items
= {}, {}, {}
1404 expected_result
= new_port
1406 "mac_adress": mac_address
,
1409 expected_created_items
= {f
"port:{port_id}": True}
1410 result
= self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1411 self
.assertDictEqual(result
, expected_result
)
1412 self
.assertEqual(net
, expected_net
)
1413 self
.assertEqual(created_items
, expected_created_items
)
1414 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1416 def test_create_new_port_without_mac_or_id(self
):
1417 """new port does not have mac address or ID."""
1419 self
.vimconn
.neutron
.create_port
.return_value
= new_port
1420 net
, port_dict
, created_items
= {}, {}, {}
1421 with self
.assertRaises(KeyError):
1422 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1423 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1425 def test_create_new_port_neutron_create_port_raises_exception(self
):
1426 """Neutron create port raises exception."""
1427 self
.vimconn
.neutron
.create_port
.side_effect
= VimConnException(
1428 "New port is not created."
1430 net
, port_dict
, created_items
= {}, {}, {}
1431 with self
.assertRaises(VimConnException
):
1432 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1433 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1435 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1436 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1437 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1438 @patch.object(vimconnector
, "_create_new_port")
1439 @patch.object(vimconnector
, "_set_fixed_ip")
1440 def test_create_port(
1443 mock_create_new_port
,
1444 mock_prepare_port_dict_mac_ip_addr
,
1445 mock_prepare_port_dict_binding
,
1446 mock_prepare_port_dict_security_groups
,
1448 """Net has name, type, net-id."""
1452 "name": "management",
1459 "mac_address": mac_address
,
1460 "name": "management",
1461 "fixed_ips": [{"ip_address": ip_addr1
}],
1464 mock_create_new_port
.return_value
= new_port
1467 "tag": "management",
1470 "network_id": net_id
,
1471 "name": "management",
1472 "admin_state_up": True,
1475 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1476 net
, name
, created_items
1479 self
.assertDictEqual(new_port_result
, new_port
)
1480 self
.assertDictEqual(port_result
, expected_port
)
1482 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1483 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1484 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1485 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1486 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1488 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1489 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1490 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1491 @patch.object(vimconnector
, "_create_new_port")
1492 @patch.object(vimconnector
, "_set_fixed_ip")
1493 def test_create_port_no_port_name(
1496 mock_create_new_port
,
1497 mock_prepare_port_dict_mac_ip_addr
,
1498 mock_prepare_port_dict_binding
,
1499 mock_prepare_port_dict_security_groups
,
1501 """Net has no name."""
1510 "mac_address": mac_address
,
1512 "fixed_ips": [{"ip_address": ip_addr1
}],
1515 mock_create_new_port
.return_value
= new_port
1521 "network_id": net_id
,
1522 "admin_state_up": True,
1526 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1527 net
, name
, created_items
1530 self
.assertDictEqual(new_port_result
, new_port
)
1531 self
.assertDictEqual(port_result
, expected_port
)
1533 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1534 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1535 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1536 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1537 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1539 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1540 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1541 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1542 @patch.object(vimconnector
, "_create_new_port")
1543 @patch.object(vimconnector
, "_set_fixed_ip")
1544 def test_create_port_nova_api_version_smaller_than_232(
1547 mock_create_new_port
,
1548 mock_prepare_port_dict_mac_ip_addr
,
1549 mock_prepare_port_dict_binding
,
1550 mock_prepare_port_dict_security_groups
,
1552 """Nova api version is smaller than 2.32."""
1553 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.30"
1562 "mac_address": mac_address
,
1564 "fixed_ips": [{"ip_address": ip_addr1
}],
1567 mock_create_new_port
.return_value
= new_port
1572 "network_id": net_id
,
1573 "admin_state_up": True,
1577 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1578 net
, name
, created_items
1581 self
.assertDictEqual(new_port_result
, new_port
)
1582 self
.assertDictEqual(port_result
, expected_port
)
1584 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1585 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1586 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1587 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1588 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1590 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1591 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1592 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1593 @patch.object(vimconnector
, "_create_new_port")
1594 @patch.object(vimconnector
, "_set_fixed_ip")
1595 def test_create_port_create_new_port_raise_exception(
1598 mock_create_new_port
,
1599 mock_prepare_port_dict_mac_ip_addr
,
1600 mock_prepare_port_dict_binding
,
1601 mock_prepare_port_dict_security_groups
,
1603 """_create_new_port method raises exception."""
1609 mock_create_new_port
.side_effect
= Exception
1611 "network_id": net_id
,
1612 "admin_state_up": True,
1616 with self
.assertRaises(Exception):
1617 self
.vimconn
._create
_port
(net
, name
, created_items
)
1619 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1620 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1621 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1622 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1623 mock_set_fixed_ip
.assert_not_called()
1625 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1626 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1627 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1628 @patch.object(vimconnector
, "_create_new_port")
1629 @patch.object(vimconnector
, "_set_fixed_ip")
1630 def test_create_port_create_sec_groups_raises_exception(
1633 mock_create_new_port
,
1634 mock_prepare_port_dict_mac_ip_addr
,
1635 mock_prepare_port_dict_binding
,
1636 mock_prepare_port_dict_security_groups
,
1638 """_prepare_port_dict_security_groups method raises exception."""
1644 mock_prepare_port_dict_security_groups
.side_effect
= Exception
1646 "network_id": net_id
,
1647 "admin_state_up": True,
1651 with self
.assertRaises(Exception):
1652 self
.vimconn
._create
_port
(net
, name
, created_items
)
1654 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1656 mock_prepare_port_dict_binding
.assert_not_called()
1657 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
1658 mock_create_new_port
.assert_not_called()
1659 mock_set_fixed_ip
.assert_not_called()
1661 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1662 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1663 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1664 @patch.object(vimconnector
, "_create_new_port")
1665 @patch.object(vimconnector
, "_set_fixed_ip")
1666 def test_create_port_create_port_dict_binding_raise_exception(
1669 mock_create_new_port
,
1670 mock_prepare_port_dict_mac_ip_addr
,
1671 mock_prepare_port_dict_binding
,
1672 mock_prepare_port_dict_security_groups
,
1674 """_prepare_port_dict_binding method raises exception."""
1681 mock_prepare_port_dict_binding
.side_effect
= Exception
1683 "network_id": net_id
,
1684 "admin_state_up": True,
1688 with self
.assertRaises(Exception):
1689 self
.vimconn
._create
_port
(net
, name
, created_items
)
1691 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1693 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1695 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
1696 mock_create_new_port
.assert_not_called()
1697 mock_set_fixed_ip
.assert_not_called()
1699 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1700 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1701 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1702 @patch.object(vimconnector
, "_create_new_port")
1703 @patch.object(vimconnector
, "_set_fixed_ip")
1704 def test_create_port_create_port_mac_ip_addr_raise_exception(
1707 mock_create_new_port
,
1708 mock_prepare_port_dict_mac_ip_addr
,
1709 mock_prepare_port_dict_binding
,
1710 mock_prepare_port_dict_security_groups
,
1712 """prepare_port_dict_mac_ip_addr method raises exception."""
1718 mock_prepare_port_dict_mac_ip_addr
.side_effect
= Exception
1720 "network_id": net_id
,
1721 "admin_state_up": True,
1725 with self
.assertRaises(Exception):
1726 self
.vimconn
._create
_port
(net
, name
, created_items
)
1728 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1729 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1730 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1732 mock_create_new_port
.assert_not_called()
1733 mock_set_fixed_ip
.assert_not_called()
1735 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1736 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1737 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1738 @patch.object(vimconnector
, "_create_new_port")
1739 @patch.object(vimconnector
, "_set_fixed_ip")
1740 def test_create_port_create_port_set_fixed_ip_raise_exception(
1743 mock_create_new_port
,
1744 mock_prepare_port_dict_mac_ip_addr
,
1745 mock_prepare_port_dict_binding
,
1746 mock_prepare_port_dict_security_groups
,
1748 """_set_fixed_ip method raises exception."""
1754 mock_set_fixed_ip
.side_effect
= VimConnException(
1755 "Port detail is missing in new_port."
1758 "network_id": net_id
,
1759 "admin_state_up": True,
1765 "mac_address": mac_address
,
1767 "fixed_ips": [{"ip_address": ip_addr1
}],
1770 mock_create_new_port
.return_value
= new_port
1772 with self
.assertRaises(VimConnException
):
1773 self
.vimconn
._create
_port
(net
, name
, created_items
)
1775 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1776 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1777 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1778 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1779 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1781 @patch.object(vimconnector
, "_reload_connection")
1782 @patch.object(vimconnector
, "_create_port")
1783 def test_prepare_network_for_vm_instance_no_net_id(
1784 self
, mock_create_port
, mock_reload_connection
1786 """Nets do not have net_id"""
1787 mock_reload_connection
.side_effect
= None
1792 "port_security": False,
1793 "exit_on_floating_ip_error": False,
1794 "port_security_disable_strategy": "full",
1797 "port_security": True,
1798 "exit_on_floating_ip_error": False,
1799 "floating_ip": True,
1803 external_network
, no_secured_ports
= [], []
1804 expected_external_network
, expected_no_secured_ports
= [], []
1805 expected_net_list_vim
= []
1807 self
.vimconn
._prepare
_network
_for
_vminstance
(
1815 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1816 self
.assertEqual(external_network
, expected_external_network
)
1817 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1819 mock_create_port
.assert_not_called()
1821 @patch.object(vimconnector
, "_reload_connection")
1822 @patch.object(vimconnector
, "_create_port")
1823 def test_prepare_network_for_vm_instance_empty_net_list(
1824 self
, mock_create_port
, mock_reload_connection
1826 """Net list is empty."""
1827 mock_reload_connection
.side_effect
= None
1830 external_network
, no_secured_ports
= [], []
1831 expected_external_network
, expected_no_secured_ports
= [], []
1832 expected_net_list_vim
= []
1834 self
.vimconn
._prepare
_network
_for
_vminstance
(
1842 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1843 self
.assertEqual(external_network
, expected_external_network
)
1844 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1846 mock_create_port
.assert_not_called()
1848 @patch.object(vimconnector
, "_reload_connection")
1849 @patch.object(vimconnector
, "_create_port")
1850 def test_prepare_network_for_vm_instance_use_floating_ip_false_mgmt_net(
1851 self
, mock_create_port
, mock_reload_connection
1853 """Nets have net-id, floating_ip False, mgmt network."""
1854 mock_reload_connection
.side_effect
= None
1859 "floating_ip": False,
1864 mock_create_port
.side_effect
= [
1869 "mac_address": mac_address
,
1873 {"port-dict": port2_id
},
1876 external_network
, no_secured_ports
= [], []
1877 expected_external_network
, expected_no_secured_ports
= [], []
1878 expected_net_list_vim
= [{"port-dict": port2_id
}]
1879 self
.vimconn
._prepare
_network
_for
_vminstance
(
1887 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1888 self
.assertEqual(external_network
, expected_external_network
)
1889 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1891 mock_create_port
.assert_called_once_with(
1894 "floating_ip": False,
1901 @patch.object(vimconnector
, "_reload_connection")
1902 def test_prepare_network_for_vm_instance_mgmt_net_net_port_security_and_floating_ip_true(
1903 self
, mock_reload_connection
1905 """Nets have net-id, use_floating_ip False in VIM config, mgmt network, net floating_ip is True."""
1906 self
.vimconn
.config
["use_floating_ip"] = False
1907 mock_create_port
= CopyingMock()
1908 mock_reload_connection
.side_effect
= None
1913 "floating_ip": True,
1918 mock_create_port
.side_effect
= [
1923 "mac_address": mac_address
,
1927 {"port-dict": port2_id
},
1930 external_network
, no_secured_ports
= [], []
1931 expected_external_network
= [
1934 "floating_ip": True,
1936 "exit_on_floating_ip_error": True,
1939 expected_no_secured_ports
= []
1940 expected_net_list_vim
= [{"port-dict": port2_id
}]
1941 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1942 self
.vimconn
._prepare
_network
_for
_vminstance
(
1950 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1951 self
.assertEqual(external_network
, expected_external_network
)
1952 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1954 mock_create_port
.assert_called_once_with(
1957 "floating_ip": True,
1964 @patch.object(vimconnector
, "_reload_connection")
1965 def test_prepare_network_for_vm_instance_use_floating_ip_true_mgmt_net_port_security_false(
1966 self
, mock_reload_connection
1968 """Nets have net-id, use_floating_ip is True in VIM config, mgmt network, net port security is False."""
1969 mock_create_port
= CopyingMock()
1970 self
.vimconn
.config
["use_floating_ip"] = True
1971 self
.vimconn
.config
["no_port_security_extension"] = False
1972 mock_reload_connection
.side_effect
= None
1979 "port_security": False,
1980 "exit_on_floating_ip_error": False,
1981 "port_security_disable_strategy": "full",
1985 mock_create_port
.side_effect
= [
1990 "mac_address": mac_address
,
1994 {"port-dict": port2_id
},
1997 external_network
, no_secured_ports
= [], []
1998 expected_external_network
= [
2002 "port_security": False,
2003 "exit_on_floating_ip_error": False,
2004 "port_security_disable_strategy": "full",
2005 "floating_ip": True,
2008 expected_no_secured_ports
= [(port2_id
, "full")]
2009 expected_net_list_vim
= [{"port-dict": port2_id
}]
2010 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2011 self
.vimconn
._prepare
_network
_for
_vminstance
(
2020 mock_create_port
.assert_called_once_with(
2024 "port_security": False,
2025 "exit_on_floating_ip_error": False,
2026 "port_security_disable_strategy": "full",
2031 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2032 self
.assertEqual(external_network
, expected_external_network
)
2033 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2035 @patch.object(vimconnector
, "_reload_connection")
2036 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_false(
2037 self
, mock_reload_connection
2039 """Nets have net-id, use_floating_ip True in VIM config, non-mgmt network, port security is False."""
2040 mock_create_port
= CopyingMock()
2041 self
.vimconn
.config
["use_floating_ip"] = True
2042 self
.vimconn
.config
["no_port_security_extension"] = False
2043 mock_reload_connection
.side_effect
= None
2050 "port_security": False,
2051 "port_security_disable_strategy": "full",
2055 mock_create_port
.side_effect
= [
2060 "mac_address": mac_address
,
2064 {"port-dict": port2_id
},
2067 external_network
, no_secured_ports
= [], []
2068 expected_external_network
= []
2069 expected_no_secured_ports
= [(port2_id
, "full")]
2070 expected_net_list_vim
= [{"port-dict": port2_id
}]
2071 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2072 self
.vimconn
._prepare
_network
_for
_vminstance
(
2081 mock_create_port
.assert_called_once_with(
2085 "port_security": False,
2086 "port_security_disable_strategy": "full",
2091 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2092 self
.assertEqual(external_network
, expected_external_network
)
2093 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2095 @patch.object(vimconnector
, "_reload_connection")
2096 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_true(
2097 self
, mock_reload_connection
2099 """Nets have net-id, use_floating_ip is True in VIM config, non-mgmt network, net port security is True."""
2100 mock_create_port
= CopyingMock()
2101 self
.vimconn
.config
["use_floating_ip"] = True
2102 self
.vimconn
.config
["no_port_security_extension"] = True
2103 mock_reload_connection
.side_effect
= None
2110 "port_security": True,
2111 "port_security_disable_strategy": "full",
2115 mock_create_port
.side_effect
= [
2120 "mac_address": mac_address
,
2124 {"port-dict": port2_id
},
2127 external_network
, no_secured_ports
= [], []
2128 expected_external_network
= []
2129 expected_no_secured_ports
= []
2130 expected_net_list_vim
= [{"port-dict": port2_id
}]
2131 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2132 self
.vimconn
._prepare
_network
_for
_vminstance
(
2141 mock_create_port
.assert_called_once_with(
2145 "port_security": True,
2146 "port_security_disable_strategy": "full",
2151 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2152 self
.assertEqual(external_network
, expected_external_network
)
2153 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2155 @patch.object(vimconnector
, "_reload_connection")
2156 def test_prepare_network_for_vm_instance_create_port_raise_exception(
2157 self
, mock_reload_connection
2159 """_create_port method raise exception."""
2160 mock_create_port
= CopyingMock()
2161 self
.vimconn
.config
["use_floating_ip"] = True
2162 self
.vimconn
.config
["no_port_security_extension"] = True
2163 mock_reload_connection
.side_effect
= None
2170 "port_security": True,
2171 "port_security_disable_strategy": "full",
2175 mock_create_port
.side_effect
= KeyError
2176 external_network
, no_secured_ports
= [], []
2177 expected_external_network
= []
2178 expected_no_secured_ports
= []
2179 expected_net_list_vim
= []
2180 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2181 with self
.assertRaises(Exception) as err
:
2182 self
.vimconn
._prepare
_network
_for
_vminstance
(
2191 self
.assertEqual(type(err
.exception
), KeyError)
2193 mock_create_port
.assert_called_once_with(
2197 "port_security": True,
2198 "port_security_disable_strategy": "full",
2203 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2204 self
.assertEqual(external_network
, expected_external_network
)
2205 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2207 @patch.object(vimconnector
, "_reload_connection")
2208 def test_prepare_network_for_vm_instance_reload_connection_raise_exception(
2209 self
, mock_reload_connection
2211 """_reload_connection method raises exception."""
2212 mock_create_port
= CopyingMock()
2213 mock_reload_connection
.side_effect
= VimConnConnectionException(
2214 "Connection failed."
2216 self
.vimconn
.config
["use_floating_ip"] = True
2217 self
.vimconn
.config
["no_port_security_extension"] = True
2224 "port_security": True,
2225 "port_security_disable_strategy": "full",
2229 mock_create_port
.side_effect
= None
2230 external_network
, no_secured_ports
= [], []
2231 expected_external_network
= []
2232 expected_no_secured_ports
= []
2233 expected_net_list_vim
= []
2234 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2235 with self
.assertRaises(Exception) as err
:
2236 self
.vimconn
._prepare
_network
_for
_vminstance
(
2245 self
.assertEqual(type(err
.exception
), VimConnConnectionException
)
2246 self
.assertEqual(str(err
.exception
), "Connection failed.")
2247 mock_reload_connection
.assert_called_once()
2248 mock_create_port
.assert_not_called()
2249 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2250 self
.assertEqual(external_network
, expected_external_network
)
2251 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2253 def test_prepare_persistent_root_volumes_vim_using_volume_id(self
):
2254 """Existing persistent root volume with vim_volume_id."""
2255 vm_av_zone
= ["nova"]
2256 base_disk_index
= ord("a")
2257 disk
= {"vim_volume_id": volume_id
}
2258 block_device_mapping
= {}
2259 existing_vim_volumes
= []
2261 expected_boot_vol_id
= None
2262 expected_block_device_mapping
= {"vda": volume_id
}
2263 expected_existing_vim_volumes
= [{"id": volume_id
}]
2264 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2269 block_device_mapping
,
2270 existing_vim_volumes
,
2273 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2274 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2275 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2276 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2278 def test_prepare_persistent_non_root_volumes_vim_using_volume_id(self
):
2279 """Existing persistent non root volume with vim_volume_id."""
2280 vm_av_zone
= ["nova"]
2281 base_disk_index
= ord("b")
2282 disk
= {"vim_volume_id": volume_id
}
2283 block_device_mapping
= {}
2284 existing_vim_volumes
= []
2286 expected_block_device_mapping
= {"vdb": volume_id
}
2287 expected_existing_vim_volumes
= [{"id": volume_id
}]
2288 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2292 block_device_mapping
,
2294 existing_vim_volumes
,
2297 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2298 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2299 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2301 def test_prepare_persistent_root_volumes_using_vim_id(self
):
2302 """Existing persistent root volume with vim_id."""
2303 vm_av_zone
= ["nova"]
2304 base_disk_index
= ord("a")
2305 disk
= {"vim_id": volume_id
}
2306 block_device_mapping
= {}
2307 existing_vim_volumes
= []
2309 expected_boot_vol_id
= None
2310 expected_block_device_mapping
= {"vda": volume_id
}
2311 expected_existing_vim_volumes
= [{"id": volume_id
}]
2312 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2317 block_device_mapping
,
2318 existing_vim_volumes
,
2321 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2322 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2323 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2324 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2326 def test_prepare_persistent_non_root_volumes_using_vim_id(self
):
2327 """Existing persistent root volume with vim_id."""
2328 vm_av_zone
= ["nova"]
2329 base_disk_index
= ord("b")
2330 disk
= {"vim_id": volume_id
}
2331 block_device_mapping
= {}
2332 existing_vim_volumes
= []
2335 expected_block_device_mapping
= {"vdb": volume_id
}
2336 expected_existing_vim_volumes
= [{"id": volume_id
}]
2337 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2341 block_device_mapping
,
2343 existing_vim_volumes
,
2347 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2348 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2349 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2351 def test_prepare_persistent_root_volumes_create(self
):
2352 """Create persistent root volume."""
2353 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
2354 vm_av_zone
= ["nova"]
2355 base_disk_index
= ord("a")
2356 disk
= {"size": 10, "image_id": image_id
}
2357 block_device_mapping
= {}
2358 existing_vim_volumes
= []
2360 expected_boot_vol_id
= volume_id2
2361 expected_block_device_mapping
= {"vda": volume_id2
}
2362 expected_existing_vim_volumes
= []
2363 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2368 block_device_mapping
,
2369 existing_vim_volumes
,
2372 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2373 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2374 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2375 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2379 availability_zone
=["nova"],
2381 self
.assertEqual(created_items
, {f
"volume:{volume_id2}": True})
2383 def test_prepare_persistent_non_root_volumes_create(self
):
2384 """Create persistent non-root volume."""
2385 self
.vimconn
.cinder
= CopyingMock()
2386 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
2387 vm_av_zone
= ["nova"]
2388 base_disk_index
= ord("a")
2390 block_device_mapping
= {}
2391 existing_vim_volumes
= []
2393 expected_block_device_mapping
= {"vda": volume_id2
}
2394 expected_existing_vim_volumes
= []
2395 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2399 block_device_mapping
,
2401 existing_vim_volumes
,
2405 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2406 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2407 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2408 size
=10, name
="basicvmvda", availability_zone
=["nova"]
2410 self
.assertEqual(created_items
, {f
"volume:{volume_id2}": True})
2412 def test_prepare_persistent_root_volumes_create_raise_exception(self
):
2413 """Create persistent root volume raise exception."""
2414 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
2415 vm_av_zone
= ["nova"]
2416 base_disk_index
= ord("a")
2417 disk
= {"size": 10, "image_id": image_id
}
2418 block_device_mapping
= {}
2419 existing_vim_volumes
= []
2422 with self
.assertRaises(Exception):
2423 result
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2428 block_device_mapping
,
2429 existing_vim_volumes
,
2433 self
.assertEqual(result
, None)
2435 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2439 availability_zone
=["nova"],
2441 self
.assertEqual(existing_vim_volumes
, [])
2442 self
.assertEqual(block_device_mapping
, {})
2443 self
.assertEqual(created_items
, {})
2445 def test_prepare_persistent_non_root_volumes_create_raise_exception(self
):
2446 """Create persistent non-root volume raise exception."""
2447 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
2448 vm_av_zone
= ["nova"]
2449 base_disk_index
= ord("b")
2451 block_device_mapping
= {}
2452 existing_vim_volumes
= []
2455 with self
.assertRaises(Exception):
2456 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2460 block_device_mapping
,
2462 existing_vim_volumes
,
2466 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2467 size
=10, name
="basicvmvdb", availability_zone
=["nova"]
2469 self
.assertEqual(existing_vim_volumes
, [])
2470 self
.assertEqual(block_device_mapping
, {})
2471 self
.assertEqual(created_items
, {})
2473 @patch("time.sleep")
2474 def test_wait_for_created_volumes_availability_volume_status_available(
2477 """Created volume status is available."""
2479 created_items
= {f
"volume:{volume_id2}": True}
2480 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
2482 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2483 elapsed_time
, created_items
2485 self
.assertEqual(result
, elapsed_time
)
2486 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2487 mock_sleep
.assert_not_called()
2489 @patch("time.sleep")
2490 def test_wait_for_existing_volumes_availability_volume_status_available(
2493 """Existing volume status is available."""
2495 existing_vim_volumes
= [{"id": volume_id2
}]
2496 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
2498 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2499 elapsed_time
, existing_vim_volumes
2501 self
.assertEqual(result
, elapsed_time
)
2502 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2503 mock_sleep
.assert_not_called()
2505 @patch("time.sleep")
2506 def test_wait_for_created_volumes_availability_status_processing_multiple_volumes(
2509 """Created volume status is processing."""
2512 f
"volume:{volume_id2}": True,
2513 f
"volume:{volume_id3}": True,
2515 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2516 Status("processing"),
2517 Status("available"),
2518 Status("available"),
2521 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2522 elapsed_time
, created_items
2524 self
.assertEqual(result
, 10)
2525 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
2526 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
2527 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
2528 self
.assertEqual(_call_mock_get_volumes
[2][0], (volume_id3
,))
2529 mock_sleep
.assert_called_with(5)
2530 self
.assertEqual(1, mock_sleep
.call_count
)
2532 @patch("time.sleep")
2533 def test_wait_for_existing_volumes_availability_status_processing_multiple_volumes(
2536 """Existing volume status is processing."""
2538 existing_vim_volumes
= [
2540 {"id": "44e0e83-b9uu-4akk-t234-p9cc4811bd4a"},
2542 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2543 Status("processing"),
2544 Status("available"),
2545 Status("available"),
2548 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2549 elapsed_time
, existing_vim_volumes
2551 self
.assertEqual(result
, 10)
2552 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
2553 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
2554 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
2556 _call_mock_get_volumes
[2][0], ("44e0e83-b9uu-4akk-t234-p9cc4811bd4a",)
2558 mock_sleep
.assert_called_with(5)
2559 self
.assertEqual(1, mock_sleep
.call_count
)
2561 @patch("time.sleep")
2562 def test_wait_for_created_volumes_availability_volume_status_processing_timeout(
2565 """Created volume status is processing, elapsed time greater than timeout (1800)."""
2567 created_items
= {f
"volume:{volume_id2}": True}
2568 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2569 Status("processing"),
2570 Status("processing"),
2572 with
patch("time.sleep", mock_sleep
):
2573 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2574 elapsed_time
, created_items
2576 self
.assertEqual(result
, 1805)
2577 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2578 mock_sleep
.assert_not_called()
2580 @patch("time.sleep")
2581 def test_wait_for_existing_volumes_availability_volume_status_processing_timeout(
2584 """Exsiting volume status is processing, elapsed time greater than timeout (1800)."""
2586 existing_vim_volumes
= [{"id": volume_id2
}]
2587 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2588 Status("processing"),
2589 Status("processing"),
2592 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2593 elapsed_time
, existing_vim_volumes
2595 self
.assertEqual(result
, 1805)
2596 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2597 mock_sleep
.assert_not_called()
2599 @patch("time.sleep")
2600 def test_wait_for_created_volumes_availability_cinder_raise_exception(
2603 """Cinder get volumes raises exception for created volumes."""
2605 created_items
= {f
"volume:{volume_id2}": True}
2606 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
2607 with self
.assertRaises(Exception):
2608 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2609 elapsed_time
, created_items
2611 self
.assertEqual(result
, 1000)
2612 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2613 mock_sleep
.assert_not_called()
2615 @patch("time.sleep")
2616 def test_wait_for_existing_volumes_availability_cinder_raise_exception(
2619 """Cinder get volumes raises exception for existing volumes."""
2621 existing_vim_volumes
= [{"id": volume_id2
}]
2622 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
2623 with self
.assertRaises(Exception):
2624 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2625 elapsed_time
, existing_vim_volumes
2627 self
.assertEqual(result
, 1000)
2628 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2629 mock_sleep
.assert_not_called()
2631 @patch("time.sleep")
2632 def test_wait_for_created_volumes_availability_no_volume_in_created_items(
2635 """Created_items dict does not have volume-id."""
2639 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
2641 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2642 elapsed_time
, created_items
2644 self
.assertEqual(result
, 10)
2645 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2646 mock_sleep
.assert_not_called()
2648 @patch("time.sleep")
2649 def test_wait_for_existing_volumes_availability_no_volume_in_existing_vim_volumes(
2652 """Existing_vim_volumes list does not have volume."""
2654 existing_vim_volumes
= []
2656 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
2658 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2659 elapsed_time
, existing_vim_volumes
2661 self
.assertEqual(result
, 10)
2662 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2663 mock_sleep
.assert_not_called()
2665 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2666 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2667 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2668 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2669 def test_prepare_disk_for_vm_instance(
2671 mock_existing_vol_availability
,
2672 mock_created_vol_availability
,
2673 mock_non_root_volumes
,
2676 """Prepare disks for VM instance successfully."""
2677 existing_vim_volumes
= []
2679 block_device_mapping
= {}
2680 vm_av_zone
= ["nova"]
2682 mock_root_volumes
.return_value
= root_vol_id
2683 mock_created_vol_availability
.return_value
= 10
2684 mock_existing_vol_availability
.return_value
= 15
2685 self
.vimconn
.cinder
= CopyingMock()
2687 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2689 existing_vim_volumes
,
2692 block_device_mapping
,
2695 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_called_once_with(
2698 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2699 mock_existing_vol_availability
.assert_called_once_with(10, existing_vim_volumes
)
2700 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2701 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2702 mock_root_volumes
.assert_called_once_with(
2704 vm_av_zone
=["nova"],
2705 disk
={"size": 10, "image_id": image_id
},
2707 block_device_mapping
={},
2708 existing_vim_volumes
=[],
2711 mock_non_root_volumes
.assert_called_once_with(
2714 vm_av_zone
=["nova"],
2716 block_device_mapping
={},
2717 existing_vim_volumes
=[],
2721 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2722 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2723 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2724 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2725 def test_prepare_disk_for_vm_instance_timeout_exceeded(
2727 mock_existing_vol_availability
,
2728 mock_created_vol_availability
,
2729 mock_non_root_volumes
,
2732 """Timeout exceeded while waiting for disks."""
2733 existing_vim_volumes
= []
2735 vm_av_zone
= ["nova"]
2736 block_device_mapping
= {}
2738 mock_root_volumes
.return_value
= root_vol_id
2739 mock_created_vol_availability
.return_value
= 1700
2740 mock_existing_vol_availability
.return_value
= 1900
2742 with self
.assertRaises(VimConnException
) as err
:
2743 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2745 existing_vim_volumes
,
2748 block_device_mapping
,
2752 str(err
.exception
), "Timeout creating volumes for instance basicvm"
2754 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2755 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2756 mock_existing_vol_availability
.assert_called_once_with(
2757 1700, existing_vim_volumes
2759 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2760 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2761 mock_root_volumes
.assert_called_once_with(
2763 vm_av_zone
=["nova"],
2764 disk
={"size": 10, "image_id": image_id
},
2766 block_device_mapping
={},
2767 existing_vim_volumes
=[],
2770 mock_non_root_volumes
.assert_called_once_with(
2773 vm_av_zone
=["nova"],
2775 block_device_mapping
={},
2776 existing_vim_volumes
=[],
2780 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2781 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2782 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2783 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2784 def test_prepare_disk_for_vm_instance_empty_disk_list(
2786 mock_existing_vol_availability
,
2787 mock_created_vol_availability
,
2788 mock_non_root_volumes
,
2791 """Disk list is empty."""
2792 existing_vim_volumes
= []
2794 block_device_mapping
= {}
2795 vm_av_zone
= ["nova"]
2796 mock_created_vol_availability
.return_value
= 2
2797 mock_existing_vol_availability
.return_value
= 3
2799 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2801 existing_vim_volumes
,
2804 block_device_mapping
,
2807 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2808 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2809 mock_existing_vol_availability
.assert_called_once_with(2, existing_vim_volumes
)
2810 mock_root_volumes
.assert_not_called()
2811 mock_non_root_volumes
.assert_not_called()
2813 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2814 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2815 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2816 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2817 def test_prepare_disk_for_vm_instance_persistent_root_volume_error(
2819 mock_existing_vol_availability
,
2820 mock_created_vol_availability
,
2821 mock_non_root_volumes
,
2824 """Persistent root volumes preparation raises error."""
2825 existing_vim_volumes
= []
2827 vm_av_zone
= ["nova"]
2828 block_device_mapping
= {}
2830 mock_root_volumes
.side_effect
= Exception()
2831 mock_created_vol_availability
.return_value
= 10
2832 mock_existing_vol_availability
.return_value
= 15
2834 with self
.assertRaises(Exception):
2835 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2837 existing_vim_volumes
,
2840 block_device_mapping
,
2843 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2844 mock_created_vol_availability
.assert_not_called()
2845 mock_existing_vol_availability
.assert_not_called()
2846 mock_root_volumes
.assert_called_once_with(
2848 vm_av_zone
=["nova"],
2849 disk
={"size": 10, "image_id": image_id
},
2851 block_device_mapping
={},
2852 existing_vim_volumes
=[],
2855 mock_non_root_volumes
.assert_not_called()
2857 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2858 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2859 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2860 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2861 def test_prepare_disk_for_vm_instance_non_root_volume_error(
2863 mock_existing_vol_availability
,
2864 mock_created_vol_availability
,
2865 mock_non_root_volumes
,
2868 """Non-root volumes preparation raises error."""
2869 existing_vim_volumes
= []
2871 vm_av_zone
= ["nova"]
2872 block_device_mapping
= {}
2874 mock_root_volumes
.return_value
= root_vol_id
2875 mock_non_root_volumes
.side_effect
= Exception
2877 with self
.assertRaises(Exception):
2878 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2880 existing_vim_volumes
,
2883 block_device_mapping
,
2886 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2887 mock_created_vol_availability
.assert_not_called()
2888 mock_existing_vol_availability
.assert_not_called()
2889 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2890 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2891 mock_root_volumes
.assert_called_once_with(
2893 vm_av_zone
=["nova"],
2894 disk
={"size": 10, "image_id": image_id
},
2896 block_device_mapping
={},
2897 existing_vim_volumes
=[],
2900 mock_non_root_volumes
.assert_called_once_with(
2903 vm_av_zone
=["nova"],
2905 block_device_mapping
={},
2906 existing_vim_volumes
=[],
2910 def test_find_external_network_for_floating_ip_no_external_network(self
):
2911 """External network could not be found."""
2912 self
.vimconn
.neutron
.list_networks
.return_value
= {
2914 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": False}
2917 with self
.assertRaises(VimConnException
) as err
:
2918 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2921 "Cannot create floating_ip automatically since no external network is present",
2924 def test_find_external_network_for_floating_one_external_network(self
):
2925 """One external network has been found."""
2926 self
.vimconn
.neutron
.list_networks
.return_value
= {
2928 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True}
2931 expected_result
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
2932 result
= self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2933 self
.assertEqual(result
, expected_result
)
2935 def test_find_external_network_for_floating_neutron_raises_exception(self
):
2936 """Neutron list networks raises exception."""
2937 self
.vimconn
.neutron
.list_networks
.side_effect
= Exception
2938 with self
.assertRaises(Exception):
2939 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2941 def test_find_external_network_for_floating_several_external_network(self
):
2942 """Several exernal networks has been found."""
2943 self
.vimconn
.neutron
.list_networks
.return_value
= {
2945 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True},
2946 {"id": "608b73-y9cc-5a6a-a270-12cc4811bd4a", "router:external": True},
2949 with self
.assertRaises(VimConnException
) as err
:
2950 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
2953 "Cannot create floating_ip automatically since multiple external networks are present",
2956 def test_neutron_create_float_ip(self
):
2957 """Floating ip creation is successful."""
2958 param
= {"net_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a"}
2960 self
.vimconn
.neutron
.create_floatingip
.return_value
= {
2961 "floatingip": {"id": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
2963 expected_created_items
= {
2964 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True
2966 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2967 self
.assertEqual(created_items
, expected_created_items
)
2969 def test_neutron_create_float_ip_exception_occurred(self
):
2970 """Floating ip could not be created."""
2973 "floating_network_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a",
2974 "tenant_id": "308b73-19cc-8a6a-a270-02cc4811bd9a",
2978 self
.vimconn
.neutron
= CopyingMock()
2979 self
.vimconn
.neutron
.create_floatingip
.side_effect
= Exception(
2980 "Neutron floating ip create exception occurred."
2982 with self
.assertRaises(VimConnException
) as err
:
2983 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
2984 self
.assertEqual(created_items
, {})
2987 "Exception: Cannot create new floating_ip Neutron floating ip create exception occurred.",
2990 @patch.object(vimconnector
, "_neutron_create_float_ip")
2991 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
2992 def test_create_floating_ip_pool_id_available(
2993 self
, mock_find_ext_network
, mock_create_float_ip
2995 """Floating ip creation, ip pool is available."""
2996 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3000 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3001 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3004 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
3005 mock_find_ext_network
.assert_not_called()
3006 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
3008 @patch.object(vimconnector
, "_neutron_create_float_ip")
3009 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
3010 def test_create_floating_ip_finding_pool_id(
3011 self
, mock_find_ext_network
, mock_create_float_ip
3013 """Floating ip creation, pool id need to be found."""
3014 floating_network
= {"floating_ip": True}
3016 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
3019 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3020 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3023 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
3024 mock_find_ext_network
.assert_called_once()
3025 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
3027 @patch.object(vimconnector
, "_neutron_create_float_ip")
3028 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
3029 def test_create_floating_ip_neutron_create_floating_ip_exception(
3030 self
, mock_find_ext_network
, mock_create_float_ip
3032 """Neutron creat floating ip raises error."""
3033 floating_network
= {"floating_ip": True}
3035 mock_create_float_ip
.side_effect
= VimConnException(
3036 "Can not create floating ip."
3038 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
3041 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3042 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3046 with self
.assertRaises(VimConnException
) as err
:
3047 self
.vimconn
._create
_floating
_ip
(
3048 floating_network
, self
.server
, created_items
3050 self
.assertEqual(str(err
.exception
), "Can not create floating ip.")
3051 mock_find_ext_network
.assert_called_once()
3052 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
3054 @patch.object(vimconnector
, "_neutron_create_float_ip")
3055 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
3056 def test_create_floating_ip_can_not_find_pool_id(
3057 self
, mock_find_ext_network
, mock_create_float_ip
3059 """Floating ip creation, pool id could not be found."""
3060 floating_network
= {"floating_ip": True}
3062 mock_find_ext_network
.side_effect
= VimConnException(
3063 "Cannot create floating_ip automatically since no external network is present"
3065 with self
.assertRaises(VimConnException
) as err
:
3066 self
.vimconn
._create
_floating
_ip
(
3067 floating_network
, self
.server
, created_items
3071 "Cannot create floating_ip automatically since no external network is present",
3073 mock_find_ext_network
.assert_called_once()
3074 mock_create_float_ip
.assert_not_called()
3076 def test_find_floating_ip_get_free_floating_ip(self
):
3077 """Get free floating ips successfully."""
3080 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3081 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3082 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3085 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3086 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3088 result
= self
.vimconn
._find
_floating
_ip
(
3089 self
.server
, floating_ips
, floating_network
3091 self
.assertEqual(result
, expected_result
)
3093 def test_find_floating_ip_different_floating_network_id(self
):
3094 """Floating network id is different with floating_ip of floating network."""
3097 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3098 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3101 floating_network
= {"floating_ip": "508b73-t9cc-1a6a-a270-12cc4811bd4a"}
3103 result
= self
.vimconn
._find
_floating
_ip
(
3104 self
.server
, floating_ips
, floating_network
3106 self
.assertEqual(result
, None)
3108 def test_find_floating_ip_different_fip_tenant(self
):
3109 """Items in floating_ips has port_id, tenant_is is not same with server tenant id."""
3112 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3113 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3114 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3115 "tenant_id": self
.server
.id,
3118 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3119 mock_create_floating_ip
= CopyingMock()
3120 with patch
.object(vimconnector
, "_create_floating_ip", mock_create_floating_ip
):
3121 result
= self
.vimconn
._find
_floating
_ip
(
3122 self
.server
, floating_ips
, floating_network
3124 self
.assertEqual(result
, None)
3126 @patch("time.sleep")
3127 def test_assign_floating_ip(self
, mock_sleep
):
3128 """Assign floating ip successfully."""
3129 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3130 floating_network
= {"vim_id": floating_network_vim_id
}
3132 "port_id": floating_network_vim_id
,
3133 "floating_network_id": "p08b73-e9cc-5a6a-t270-82cc4811bd4a",
3134 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3135 "tenant_id": "k08b73-e9cc-5a6a-t270-82cc4811bd4a",
3137 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
3138 self
.vimconn
.neutron
.show_floatingip
.return_value
= fip
3139 expected_result
= fip
3141 result
= self
.vimconn
._assign
_floating
_ip
(free_floating_ip
, floating_network
)
3142 self
.assertEqual(result
, expected_result
)
3143 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3145 {"floatingip": {"port_id": floating_network_vim_id
}},
3147 mock_sleep
.assert_called_once_with(5)
3148 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
3150 @patch("time.sleep")
3151 def test_assign_floating_ip_update_floating_ip_exception(self
, mock_sleep
):
3152 """Neutron update floating ip raises exception."""
3153 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3154 floating_network
= {"vim_id": floating_network_vim_id
}
3155 self
.vimconn
.neutron
= CopyingMock()
3156 self
.vimconn
.neutron
.update_floatingip
.side_effect
= Exception(
3157 "Floating ip is not updated."
3160 with self
.assertRaises(Exception) as err
:
3161 result
= self
.vimconn
._assign
_floating
_ip
(
3162 free_floating_ip
, floating_network
3164 self
.assertEqual(result
, None)
3165 self
.assertEqual(str(err
.exception
), "Floating ip is not updated.")
3167 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3169 {"floatingip": {"port_id": floating_network_vim_id
}},
3171 mock_sleep
.assert_not_called()
3172 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3174 @patch("time.sleep")
3175 def test_assign_floating_ip_show_floating_ip_exception(self
, mock_sleep
):
3176 """Neutron show floating ip raises exception."""
3177 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3178 floating_network
= {"vim_id": floating_network_vim_id
}
3179 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
3180 self
.vimconn
.neutron
.show_floatingip
.side_effect
= Exception(
3181 "Floating ip could not be shown."
3184 with self
.assertRaises(Exception) as err
:
3185 result
= self
.vimconn
._assign
_floating
_ip
(
3186 free_floating_ip
, floating_network
3188 self
.assertEqual(result
, None)
3189 self
.assertEqual(str(err
.exception
), "Floating ip could not be shown.")
3190 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3192 {"floatingip": {"port_id": floating_network_vim_id
}},
3194 mock_sleep
.assert_called_once_with(5)
3195 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
3197 @patch("random.shuffle")
3198 @patch.object(vimconnector
, "_find_floating_ip")
3199 def test_get_free_floating_ip(self
, mock_find_floating_ip
, mock_shuffle
):
3200 """Get free floating ip successfully."""
3201 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3204 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3205 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3206 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3207 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3210 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3211 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3212 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3213 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3216 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
3217 "floatingips": floating_ips
3219 mock_find_floating_ip
.return_value
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3220 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3222 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3223 self
.assertEqual(result
, expected_result
)
3224 mock_shuffle
.assert_called_once_with(floating_ips
)
3225 mock_find_floating_ip
.assert_called_once_with(
3226 self
.server
, floating_ips
, floating_network
3229 @patch("random.shuffle")
3230 @patch.object(vimconnector
, "_find_floating_ip")
3231 def test_get_free_floating_ip_list_floating_ip_exception(
3232 self
, mock_find_floating_ip
, mock_shuffle
3234 """Neutron list floating IPs raises exception."""
3235 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3236 self
.vimconn
.neutron
= CopyingMock()
3237 self
.vimconn
.neutron
.list_floatingips
.side_effect
= Exception(
3238 "Floating ips could not be listed."
3240 with self
.assertRaises(Exception) as err
:
3241 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3242 self
.assertEqual(result
, None)
3243 self
.assertEqual(str(err
.exception
), "Floating ips could not be listed.")
3244 mock_shuffle
.assert_not_called()
3245 mock_find_floating_ip
.assert_not_called()
3247 @patch("random.shuffle")
3248 @patch.object(vimconnector
, "_find_floating_ip")
3249 def test_get_free_floating_ip_find_floating_ip_exception(
3250 self
, mock_find_floating_ip
, mock_shuffle
3252 """_find_floating_ip method raises exception."""
3253 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3256 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3257 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3258 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3259 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3262 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3263 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3264 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3265 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3268 self
.vimconn
.neutron
= CopyingMock()
3269 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
3270 "floatingips": floating_ips
3272 mock_find_floating_ip
.side_effect
= Exception(
3273 "Free floating ip could not be found."
3276 with self
.assertRaises(Exception) as err
:
3277 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3278 self
.assertEqual(result
, None)
3279 self
.assertEqual(str(err
.exception
), "Free floating ip could not be found.")
3280 mock_shuffle
.assert_called_once_with(floating_ips
)
3281 mock_find_floating_ip
.assert_called_once_with(
3282 self
.server
, floating_ips
, floating_network
3285 @patch.object(vimconnector
, "_create_floating_ip")
3286 @patch.object(vimconnector
, "_get_free_floating_ip")
3287 @patch.object(vimconnector
, "_assign_floating_ip")
3288 def test_prepare_external_network_for_vm_instance(
3290 mock_assign_floating_ip
,
3291 mock_get_free_floating_ip
,
3292 mock_create_floating_ip
,
3294 """Prepare external network successfully."""
3295 external_network
= [
3297 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3298 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3302 vm_start_time
= time_return_value
3303 mock_get_free_floating_ip
.side_effect
= ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
3304 mock_assign_floating_ip
.return_value
= {
3305 "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
3307 self
.vimconn
.neutron
= CopyingMock()
3308 self
.vimconn
.nova
= CopyingMock()
3309 self
.vimconn
.neutron
.show_floatingip
.return_value
= {
3310 "floatingip": {"port_id": ""}
3313 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3314 external_network
, self
.server
, created_items
, vm_start_time
3317 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3318 mock_get_free_floating_ip
.assert_called_once_with(
3321 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3322 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3325 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(
3326 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3328 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3329 mock_create_floating_ip
.assert_not_called()
3330 mock_assign_floating_ip
.assert_called_once_with(
3331 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3333 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3334 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3339 @patch("time.sleep")
3340 @patch.object(vimconnector
, "_create_floating_ip")
3341 @patch.object(vimconnector
, "_get_free_floating_ip")
3342 @patch.object(vimconnector
, "_assign_floating_ip")
3343 def test_prepare_external_network_for_vm_instance_no_free_floating_ip(
3345 mock_assign_floating_ip
,
3346 mock_get_free_floating_ip
,
3347 mock_create_floating_ip
,
3351 """There is not any free floating ip."""
3352 floating_network
= {
3353 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3354 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3356 external_network
= [floating_network
]
3359 vm_start_time
= time_return_value
3360 mock_get_free_floating_ip
.return_value
= None
3361 mock_assign_floating_ip
.return_value
= {}
3362 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3363 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3365 with self
.assertRaises(KeyError):
3366 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3367 external_network
, self
.server
, created_items
, vm_start_time
3370 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3371 mock_get_free_floating_ip
.assert_called_with(
3374 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3375 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3378 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(None)
3379 mock_sleep
.assert_not_called()
3380 mock_time
.assert_not_called()
3381 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3382 mock_create_floating_ip
.assert_called_with(
3383 floating_network
, self
.server
, created_items
3385 self
.assertEqual(mock_create_floating_ip
.call_count
, 4)
3386 mock_assign_floating_ip
.assert_not_called()
3387 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3390 @patch("time.sleep")
3391 @patch.object(vimconnector
, "_create_floating_ip")
3392 @patch.object(vimconnector
, "_get_free_floating_ip")
3393 @patch.object(vimconnector
, "_assign_floating_ip")
3394 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
3396 mock_assign_floating_ip
,
3397 mock_get_free_floating_ip
,
3398 mock_create_floating_ip
,
3402 """There is not any free floating ip, create_floating ip method raise exception
3403 exit_on_floating_ip_error set to False."""
3404 floating_network
= {
3405 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3406 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3407 "exit_on_floating_ip_error": False,
3409 external_network
= [floating_network
]
3412 vm_start_time
= time_return_value
3413 mock_get_free_floating_ip
.return_value
= None
3414 mock_assign_floating_ip
.return_value
= {}
3415 mock_create_floating_ip
.side_effect
= VimConnException(
3416 "Can not create floating ip."
3418 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3419 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3421 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3422 external_network
, self
.server
, created_items
, vm_start_time
3424 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3425 mock_get_free_floating_ip
.assert_called_with(
3428 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3429 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3430 "exit_on_floating_ip_error": False,
3433 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3434 mock_sleep
.assert_not_called()
3435 mock_time
.assert_not_called()
3436 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3437 mock_create_floating_ip
.assert_called_with(
3438 floating_network
, self
.server
, created_items
3440 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
3441 mock_assign_floating_ip
.assert_not_called()
3444 @patch("time.sleep")
3445 @patch.object(vimconnector
, "_create_floating_ip")
3446 @patch.object(vimconnector
, "_get_free_floating_ip")
3447 @patch.object(vimconnector
, "_assign_floating_ip")
3448 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
3450 mock_assign_floating_ip
,
3451 mock_get_free_floating_ip
,
3452 mock_create_floating_ip
,
3456 """There is not any free floating ip, create_floating ip method raise exception
3457 exit_on_floating_ip_error set to False."""
3458 floating_network
= {
3459 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3460 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3461 "exit_on_floating_ip_error": True,
3463 external_network
= [floating_network
]
3466 vm_start_time
= time_return_value
3467 mock_get_free_floating_ip
.return_value
= None
3468 mock_assign_floating_ip
.return_value
= {}
3469 mock_create_floating_ip
.side_effect
= VimConnException(
3470 "Can not create floating ip."
3472 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3473 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3474 with self
.assertRaises(VimConnException
):
3475 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3476 external_network
, self
.server
, created_items
, vm_start_time
3478 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3479 mock_get_free_floating_ip
.assert_called_with(
3482 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3483 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3484 "exit_on_floating_ip_error": True,
3487 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3488 mock_sleep
.assert_not_called()
3489 mock_time
.assert_not_called()
3490 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3491 mock_create_floating_ip
.assert_called_with(
3492 floating_network
, self
.server
, created_items
3494 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
3495 mock_assign_floating_ip
.assert_not_called()
3497 @patch.object(vimconnector
, "_create_floating_ip")
3498 @patch.object(vimconnector
, "_get_free_floating_ip")
3499 @patch.object(vimconnector
, "_assign_floating_ip")
3500 def test_prepare_external_network_for_vm_instance_fip_has_port_id(
3502 mock_assign_floating_ip
,
3503 mock_get_free_floating_ip
,
3504 mock_create_floating_ip
,
3506 """Neutron show floating ip return the fip with port_id and floating network vim_id
3507 is different from port_id."""
3508 floating_network
= {
3509 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3510 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3512 external_network
= [floating_network
]
3515 mock_get_free_floating_ip
.side_effect
= [
3516 "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
3517 "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
3518 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3520 mock_assign_floating_ip
.side_effect
= [
3521 {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3522 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3524 self
.vimconn
.neutron
= CopyingMock()
3525 self
.vimconn
.nova
= CopyingMock()
3526 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3527 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3528 {"floatingip": {"port_id": ""}},
3529 {"floatingip": {"port_id": ""}},
3531 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3532 external_network
, self
.server
, created_items
, vm_start_time
3534 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3535 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3537 _call_mock_get_free_floating_ip
[0][0],
3544 _call_mock_get_free_floating_ip
[1][0],
3551 _call_mock_get_free_floating_ip
[2][0],
3557 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3558 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3559 mock_create_floating_ip
.assert_not_called()
3560 self
.assertEqual(mock_assign_floating_ip
.call_count
, 2)
3561 _call_mock_assign_floating_ip
= mock_assign_floating_ip
.call_args_list
3563 _call_mock_assign_floating_ip
[0][0],
3564 ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
3567 _call_mock_assign_floating_ip
[1][0],
3568 ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
3572 @patch("time.sleep")
3573 @patch.object(vimconnector
, "_create_floating_ip")
3574 @patch.object(vimconnector
, "_get_free_floating_ip")
3575 @patch.object(vimconnector
, "_assign_floating_ip")
3576 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
3578 mock_assign_floating_ip
,
3579 mock_get_free_floating_ip
,
3580 mock_create_floating_ip
,
3584 """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
3585 VM status is in error."""
3586 floating_network
= {
3587 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3588 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3589 "exit_on_floating_ip_error": True,
3591 external_network
= [floating_network
]
3593 vm_start_time
= time_return_value
3595 mock_time
.side_effect
= [156570150, 156570800, 156571200]
3597 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3598 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3599 Exception("Floating ip could not be shown.")
3601 with self
.assertRaises(Exception) as err
:
3602 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3603 external_network
, self
.server
, created_items
, vm_start_time
3607 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3610 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3611 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3613 _call_mock_get_free_floating_ip
[0][0],
3620 _call_mock_get_free_floating_ip
[1][0],
3627 _call_mock_get_free_floating_ip
[2][0],
3634 _call_mock_get_free_floating_ip
[3][0],
3641 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3642 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3643 mock_create_floating_ip
.assert_not_called()
3644 mock_assign_floating_ip
.assert_not_called()
3645 mock_time
.assert_not_called()
3646 mock_sleep
.assert_not_called()
3649 @patch("time.sleep")
3650 @patch.object(vimconnector
, "_create_floating_ip")
3651 @patch.object(vimconnector
, "_get_free_floating_ip")
3652 @patch.object(vimconnector
, "_assign_floating_ip")
3653 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
3655 mock_assign_floating_ip
,
3656 mock_get_free_floating_ip
,
3657 mock_create_floating_ip
,
3661 """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
3662 VM status is in active."""
3663 floating_network
= {
3664 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3665 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3666 "exit_on_floating_ip_error": False,
3668 external_network
= [floating_network
]
3670 vm_start_time
= time_return_value
3672 mock_time
.side_effect
= [156570150, 156570800, 156571200]
3674 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ACTIVE"
3675 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3676 Exception("Floating ip could not be shown.")
3679 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3680 external_network
, self
.server
, created_items
, vm_start_time
3682 # self.assertEqual(str(err.exception), "Cannot create floating_ip")
3684 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3685 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3687 _call_mock_get_free_floating_ip
[0][0],
3694 _call_mock_get_free_floating_ip
[1][0],
3701 _call_mock_get_free_floating_ip
[2][0],
3708 _call_mock_get_free_floating_ip
[3][0],
3715 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3716 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3717 mock_create_floating_ip
.assert_not_called()
3718 mock_assign_floating_ip
.assert_not_called()
3719 mock_time
.assert_not_called()
3720 mock_sleep
.assert_not_called()
3723 @patch("time.sleep")
3724 @patch.object(vimconnector
, "_create_floating_ip")
3725 @patch.object(vimconnector
, "_get_free_floating_ip")
3726 @patch.object(vimconnector
, "_assign_floating_ip")
3727 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
3729 mock_assign_floating_ip
,
3730 mock_get_free_floating_ip
,
3731 mock_create_floating_ip
,
3735 """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
3736 VM status is not ACTIVE or ERROR, server timeout happened."""
3737 floating_network
= {
3738 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3739 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3740 "exit_on_floating_ip_error": True,
3742 external_network
= [floating_network
]
3744 vm_start_time
= time_return_value
3745 mock_get_free_floating_ip
.side_effect
= None
3746 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3747 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "OTHER"
3748 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3749 Exception("Floating ip could not be shown.")
3752 with self
.assertRaises(VimConnException
) as err
:
3753 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3754 external_network
, self
.server
, created_items
, vm_start_time
3758 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3761 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3762 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3764 _call_mock_get_free_floating_ip
[0][0],
3771 _call_mock_get_free_floating_ip
[1][0],
3778 _call_mock_get_free_floating_ip
[2][0],
3785 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3786 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3787 mock_create_floating_ip
.assert_not_called()
3788 mock_assign_floating_ip
.assert_not_called()
3789 self
.assertEqual(mock_time
.call_count
, 3)
3790 self
.assertEqual(mock_sleep
.call_count
, 2)
3793 @patch("time.sleep")
3794 @patch.object(vimconnector
, "_create_floating_ip")
3795 @patch.object(vimconnector
, "_get_free_floating_ip")
3796 @patch.object(vimconnector
, "_assign_floating_ip")
3797 def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3799 mock_assign_floating_ip
,
3800 mock_get_free_floating_ip
,
3801 mock_create_floating_ip
,
3805 """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3806 VM status is in ERROR."""
3807 floating_network
= {
3808 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3809 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3810 "exit_on_floating_ip_error": True,
3812 external_network
= [floating_network
]
3814 vm_start_time
= time_return_value
3816 mock_get_free_floating_ip
.side_effect
= [
3817 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3820 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3822 mock_assign_floating_ip
.side_effect
= [
3823 Exception("Floating ip could not be assigned.")
3826 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3827 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3828 {"floatingip": {"port_id": ""}}
3831 with self
.assertRaises(VimConnException
) as err
:
3832 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3833 external_network
, self
.server
, created_items
, vm_start_time
3837 "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3840 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3841 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3843 _call_mock_get_free_floating_ip
[0][0],
3850 _call_mock_get_free_floating_ip
[1][0],
3857 _call_mock_get_free_floating_ip
[2][0],
3864 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3865 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(
3866 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3868 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3869 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3870 mock_time
.assert_not_called()
3871 mock_sleep
.assert_not_called()
3872 mock_create_floating_ip
.assert_not_called()
3875 @patch("time.sleep")
3876 @patch.object(vimconnector
, "_create_floating_ip")
3877 @patch.object(vimconnector
, "_get_free_floating_ip")
3878 @patch.object(vimconnector
, "_assign_floating_ip")
3879 def test_prepare_external_network_for_vm_instance_empty_external_network_list(
3881 mock_assign_floating_ip
,
3882 mock_get_free_floating_ip
,
3883 mock_create_floating_ip
,
3887 """External network list is empty."""
3888 external_network
= []
3890 vm_start_time
= time_return_value
3892 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3893 external_network
, self
.server
, created_items
, vm_start_time
3895 mock_create_floating_ip
.assert_not_called()
3896 mock_time
.assert_not_called()
3897 mock_sleep
.assert_not_called()
3898 mock_assign_floating_ip
.assert_not_called()
3899 mock_get_free_floating_ip
.assert_not_called()
3900 self
.vimconn
.neutron
.show
.show_floatingip
.assert_not_called()
3901 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3903 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3904 def test_update_port_security_for_vm_instance(self
, mock_wait_for_vm
):
3905 """no_secured_ports has port and the port has allow-address-pairs."""
3906 no_secured_ports
= [(port2_id
, "allow-address-pairs")]
3908 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3910 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3912 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3914 {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
3917 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3918 def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
3919 self
, mock_wait_for_vm
3921 """no_secured_ports has port and the port does not have allow-address-pairs."""
3922 no_secured_ports
= [(port2_id
, "something")]
3924 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3926 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3928 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3930 {"port": {"port_security_enabled": False, "security_groups": None}},
3933 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3934 def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
3935 self
, mock_wait_for_vm
3937 """__wait_for_vm raises timeout exception."""
3938 no_secured_ports
= [(port2_id
, "something")]
3940 mock_wait_for_vm
.side_effect
= VimConnException("Timeout waiting for instance.")
3942 with self
.assertRaises(VimConnException
) as err
:
3943 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3944 no_secured_ports
, self
.server
3946 self
.assertEqual(str(err
.exception
), "Timeout waiting for instance.")
3948 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3950 self
.vimconn
.neutron
.update_port
.assert_not_called()
3952 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3953 def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
3954 self
, mock_wait_for_vm
3956 """neutron_update_port method raises exception."""
3957 no_secured_ports
= [(port2_id
, "something")]
3959 self
.vimconn
.neutron
.update_port
.side_effect
= Exception(
3960 "Port security could not be updated."
3963 with self
.assertRaises(VimConnException
) as err
:
3964 self
.vimconn
._update
_port
_security
_for
_vminstance
(
3965 no_secured_ports
, self
.server
3969 "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
3971 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
3973 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
3975 {"port": {"port_security_enabled": False, "security_groups": None}},
3978 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
3979 def test_update_port_security_for_vm_instance_empty_port_list(
3980 self
, mock_wait_for_vm
3982 """no_secured_ports list does not have any ports."""
3983 no_secured_ports
= []
3985 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
3987 mock_wait_for_vm
.assert_not_called()
3989 self
.vimconn
.neutron
.update_port
.assert_not_called()
3992 @patch.object(vimconnector
, "_reload_connection")
3993 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
3994 @patch.object(vimconnector
, "_create_user_data")
3995 @patch.object(vimconnector
, "_get_vm_availability_zone")
3996 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
3997 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
3998 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
3999 @patch.object(vimconnector
, "delete_vminstance")
4000 @patch.object(vimconnector
, "_format_exception")
4001 def test_new_vm_instance(
4003 mock_format_exception
,
4004 mock_delete_vm_instance
,
4005 mock_prepare_external_network
,
4006 mock_update_port_security
,
4007 mock_prepare_disk_for_vm_instance
,
4008 mock_get_vm_availability_zone
,
4009 mock_create_user_data
,
4010 mock_prepare_network_for_vm_instance
,
4011 mock_reload_connection
,
4014 """New VM instance creation is successful."""
4016 mock_create_user_data
.return_value
= True, "userdata"
4018 mock_get_vm_availability_zone
.return_value
= "nova"
4020 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4022 mock_time
.return_value
= time_return_value
4024 expected_result
= self
.server
.id, {}
4026 result
= self
.vimconn
.new_vminstance(
4032 affinity_group_list
,
4036 availability_zone_index
,
4037 availability_zone_list
,
4039 self
.assertEqual(result
, expected_result
)
4041 mock_reload_connection
.assert_called_once()
4042 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4047 external_network
=[],
4048 no_secured_ports
=[],
4050 mock_create_user_data
.assert_called_once_with(cloud_config
)
4051 mock_get_vm_availability_zone
.assert_called_once_with(
4052 availability_zone_index
, availability_zone_list
4054 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4056 existing_vim_volumes
=[],
4059 block_device_mapping
={},
4060 disk_list
=disk_list2
,
4062 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4067 security_groups
="default",
4068 availability_zone
="nova",
4069 key_name
="my_keypair",
4070 userdata
="userdata",
4072 block_device_mapping
={},
4075 mock_time
.assert_called_once()
4076 mock_update_port_security
.assert_called_once_with([], self
.server
)
4077 mock_prepare_external_network
.assert_called_once_with(
4078 external_network
=[],
4081 vm_start_time
=time_return_value
,
4083 mock_delete_vm_instance
.assert_not_called()
4084 mock_format_exception
.assert_not_called()
4087 @patch.object(vimconnector
, "_reload_connection")
4088 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4089 @patch.object(vimconnector
, "_create_user_data")
4090 @patch.object(vimconnector
, "_get_vm_availability_zone")
4091 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4092 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4093 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4094 @patch.object(vimconnector
, "delete_vminstance")
4095 @patch.object(vimconnector
, "_format_exception")
4096 def test_new_vm_instance_create_user_data_fails(
4098 mock_format_exception
,
4099 mock_delete_vm_instance
,
4100 mock_prepare_external_network
,
4101 mock_update_port_security
,
4102 mock_prepare_disk_for_vm_instance
,
4103 mock_get_vm_availability_zone
,
4104 mock_create_user_data
,
4105 mock_prepare_network_for_vm_instance
,
4106 mock_reload_connection
,
4109 """New VM instance creation failed because of user data creation failure."""
4111 mock_create_user_data
.side_effect
= Exception(
4112 "User data could not be retrieved."
4115 mock_get_vm_availability_zone
.return_value
= "nova"
4117 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4119 mock_time
.return_value
= time_return_value
4121 self
.vimconn
.new_vminstance(
4127 affinity_group_list
,
4131 availability_zone_index
,
4132 availability_zone_list
,
4135 mock_reload_connection
.assert_called_once()
4136 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4141 external_network
=[],
4142 no_secured_ports
=[],
4144 mock_create_user_data
.assert_called_once_with(cloud_config
)
4145 mock_get_vm_availability_zone
.assert_not_called()
4146 mock_prepare_disk_for_vm_instance
.assert_not_called()
4147 self
.vimconn
.nova
.servers
.create
.assert_not_called()
4148 mock_time
.assert_not_called()
4149 mock_update_port_security
.assert_not_called()
4150 mock_prepare_external_network
.assert_not_called()
4151 mock_delete_vm_instance
.assert_called_once_with(None, {})
4152 mock_format_exception
.assert_called_once()
4153 arg
= mock_format_exception
.call_args
[0][0]
4154 self
.assertEqual(str(arg
), "User data could not be retrieved.")
4157 @patch.object(vimconnector
, "_reload_connection")
4158 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4159 @patch.object(vimconnector
, "_create_user_data")
4160 @patch.object(vimconnector
, "_get_vm_availability_zone")
4161 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4162 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4163 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4164 @patch.object(vimconnector
, "delete_vminstance")
4165 @patch.object(vimconnector
, "_format_exception")
4166 def test_new_vm_instance_external_network_exception(
4168 mock_format_exception
,
4169 mock_delete_vm_instance
,
4170 mock_prepare_external_network
,
4171 mock_update_port_security
,
4172 mock_prepare_disk_for_vm_instance
,
4173 mock_get_vm_availability_zone
,
4174 mock_create_user_data
,
4175 mock_prepare_network_for_vm_instance
,
4176 mock_reload_connection
,
4179 """New VM instance creation, external network connection has failed as floating
4180 ip could not be created."""
4182 mock_create_user_data
.return_value
= True, "userdata"
4184 mock_get_vm_availability_zone
.return_value
= "nova"
4186 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4188 mock_time
.return_value
= time_return_value
4190 mock_prepare_external_network
.side_effect
= VimConnException(
4191 "Can not create floating ip."
4194 self
.vimconn
.new_vminstance(
4200 affinity_group_list
,
4204 availability_zone_index
,
4205 availability_zone_list
,
4208 mock_reload_connection
.assert_called_once()
4209 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4214 external_network
=[],
4215 no_secured_ports
=[],
4217 mock_create_user_data
.assert_called_once_with(cloud_config
)
4218 mock_get_vm_availability_zone
.assert_called_once_with(
4219 availability_zone_index
, availability_zone_list
4221 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4223 existing_vim_volumes
=[],
4226 block_device_mapping
={},
4227 disk_list
=disk_list2
,
4229 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4234 security_groups
="default",
4235 availability_zone
="nova",
4236 key_name
="my_keypair",
4237 userdata
="userdata",
4239 block_device_mapping
={},
4242 mock_time
.assert_called_once()
4243 mock_update_port_security
.assert_called_once_with([], self
.server
)
4244 mock_prepare_external_network
.assert_called_once_with(
4245 external_network
=[],
4248 vm_start_time
=time_return_value
,
4250 mock_delete_vm_instance
.assert_called_once_with(self
.server
.id, {})
4251 mock_format_exception
.assert_called_once()
4252 arg
= mock_format_exception
.call_args
[0][0]
4253 self
.assertEqual(str(arg
), "Can not create floating ip.")
4256 @patch.object(vimconnector
, "_reload_connection")
4257 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4258 @patch.object(vimconnector
, "_create_user_data")
4259 @patch.object(vimconnector
, "_get_vm_availability_zone")
4260 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4261 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4262 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4263 @patch.object(vimconnector
, "delete_vminstance")
4264 @patch.object(vimconnector
, "_format_exception")
4265 def test_new_vm_instance_with_affinity_group(
4267 mock_format_exception
,
4268 mock_delete_vm_instance
,
4269 mock_prepare_external_network
,
4270 mock_update_port_security
,
4271 mock_prepare_disk_for_vm_instance
,
4272 mock_get_vm_availability_zone
,
4273 mock_create_user_data
,
4274 mock_prepare_network_for_vm_instance
,
4275 mock_reload_connection
,
4278 """New VM creation with affinity group."""
4279 affinity_group_list
= [
4280 {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
4282 mock_create_user_data
.return_value
= True, "userdata"
4283 mock_get_vm_availability_zone
.return_value
= "nova"
4284 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4285 mock_time
.return_value
= time_return_value
4286 expected_result
= self
.server
.id, {}
4288 result
= self
.vimconn
.new_vminstance(
4294 affinity_group_list
,
4298 availability_zone_index
,
4299 availability_zone_list
,
4301 self
.assertEqual(result
, expected_result
)
4303 mock_reload_connection
.assert_called_once()
4304 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4309 external_network
=[],
4310 no_secured_ports
=[],
4312 mock_create_user_data
.assert_called_once_with(cloud_config
)
4313 mock_get_vm_availability_zone
.assert_called_once_with(
4314 availability_zone_index
, availability_zone_list
4316 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4318 existing_vim_volumes
=[],
4321 block_device_mapping
={},
4322 disk_list
=disk_list2
,
4324 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4329 security_groups
="default",
4330 availability_zone
="nova",
4331 key_name
="my_keypair",
4332 userdata
="userdata",
4334 block_device_mapping
={},
4335 scheduler_hints
={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
4337 mock_time
.assert_called_once()
4338 mock_update_port_security
.assert_called_once_with([], self
.server
)
4339 mock_prepare_external_network
.assert_called_once_with(
4340 external_network
=[],
4343 vm_start_time
=time_return_value
,
4345 mock_delete_vm_instance
.assert_not_called()
4346 mock_format_exception
.assert_not_called()
4349 @patch.object(vimconnector
, "_reload_connection")
4350 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4351 @patch.object(vimconnector
, "_create_user_data")
4352 @patch.object(vimconnector
, "_get_vm_availability_zone")
4353 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4354 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4355 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4356 @patch.object(vimconnector
, "delete_vminstance")
4357 @patch.object(vimconnector
, "_format_exception")
4358 def test_new_vm_instance_nova_server_create_failed(
4360 mock_format_exception
,
4361 mock_delete_vm_instance
,
4362 mock_prepare_external_network
,
4363 mock_update_port_security
,
4364 mock_prepare_disk_for_vm_instance
,
4365 mock_get_vm_availability_zone
,
4366 mock_create_user_data
,
4367 mock_prepare_network_for_vm_instance
,
4368 mock_reload_connection
,
4371 """New VM(server) creation failed."""
4373 mock_create_user_data
.return_value
= True, "userdata"
4375 mock_get_vm_availability_zone
.return_value
= "nova"
4377 self
.vimconn
.nova
.servers
.create
.side_effect
= Exception(
4378 "Server could not be created."
4381 mock_time
.return_value
= time_return_value
4383 self
.vimconn
.new_vminstance(
4389 affinity_group_list
,
4393 availability_zone_index
,
4394 availability_zone_list
,
4397 mock_reload_connection
.assert_called_once()
4398 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4403 external_network
=[],
4404 no_secured_ports
=[],
4406 mock_create_user_data
.assert_called_once_with(cloud_config
)
4407 mock_get_vm_availability_zone
.assert_called_once_with(
4408 availability_zone_index
, availability_zone_list
4410 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4412 existing_vim_volumes
=[],
4415 block_device_mapping
={},
4416 disk_list
=disk_list2
,
4419 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4424 security_groups
="default",
4425 availability_zone
="nova",
4426 key_name
="my_keypair",
4427 userdata
="userdata",
4429 block_device_mapping
={},
4432 mock_time
.assert_not_called()
4433 mock_update_port_security
.assert_not_called()
4434 mock_prepare_external_network
.assert_not_called()
4435 mock_delete_vm_instance
.assert_called_once_with(None, {})
4436 mock_format_exception
.assert_called_once()
4437 arg
= mock_format_exception
.call_args
[0][0]
4438 self
.assertEqual(str(arg
), "Server could not be created.")
4441 @patch.object(vimconnector
, "_reload_connection")
4442 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4443 @patch.object(vimconnector
, "_create_user_data")
4444 @patch.object(vimconnector
, "_get_vm_availability_zone")
4445 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4446 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4447 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4448 @patch.object(vimconnector
, "delete_vminstance")
4449 @patch.object(vimconnector
, "_format_exception")
4450 def test_new_vm_instance_connection_exception(
4452 mock_format_exception
,
4453 mock_delete_vm_instance
,
4454 mock_prepare_external_network
,
4455 mock_update_port_security
,
4456 mock_prepare_disk_for_vm_instance
,
4457 mock_get_vm_availability_zone
,
4458 mock_create_user_data
,
4459 mock_prepare_network_for_vm_instance
,
4460 mock_reload_connection
,
4463 """Connection to Cloud API has failed."""
4464 mock_reload_connection
.side_effect
= Exception("Can not connect to Cloud APIs.")
4465 mock_create_user_data
.return_value
= True, "userdata"
4466 mock_get_vm_availability_zone
.return_value
= "nova"
4467 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4468 mock_time
.return_value
= time_return_value
4470 self
.vimconn
.new_vminstance(
4476 affinity_group_list
,
4480 availability_zone_index
,
4481 availability_zone_list
,
4483 mock_format_exception
.assert_called_once()
4484 arg
= mock_format_exception
.call_args
[0][0]
4485 self
.assertEqual(str(arg
), "Can not connect to Cloud APIs.")
4486 mock_reload_connection
.assert_called_once()
4487 mock_prepare_network_for_vm_instance
.assert_not_called()
4488 mock_create_user_data
.assert_not_called()
4489 mock_get_vm_availability_zone
.assert_not_called()
4490 mock_prepare_disk_for_vm_instance
.assert_not_called()
4491 self
.vimconn
.nova
.servers
.create
.assert_not_called()
4492 mock_time
.assert_not_called()
4493 mock_update_port_security
.assert_not_called()
4494 mock_prepare_external_network
.assert_not_called()
4495 mock_delete_vm_instance
.assert_called_once_with(None, {})
4497 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4498 def test_delete_vm_ports_attached_to_network_empty_created_items(
4499 self
, mock_delete_ports_by_id_wth_neutron
4501 """Created_items is emtpty."""
4503 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4504 self
.vimconn
.neutron
.list_ports
.assert_not_called()
4505 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4506 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4508 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4509 def test_delete_vm_ports_attached_to_network(
4510 self
, mock_delete_ports_by_id_wth_neutron
4513 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
4514 f
"volume:{volume_id2}": True,
4515 f
"volume:{volume_id}": True,
4516 f
"port:{port_id}": True,
4518 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4519 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4520 self
.vimconn
.logger
.error
.assert_not_called()
4522 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4523 def test_delete_vm_ports_attached_to_network_wthout_port(
4524 self
, mock_delete_ports_by_id_wth_neutron
4526 """Created_items does not have port."""
4528 f
"floating_ip:{floating_network_vim_id}": True,
4529 f
"volume:{volume_id2}": True,
4530 f
"volume:{volume_id}": True,
4532 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4533 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4534 self
.vimconn
.logger
.error
.assert_not_called()
4536 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4537 def test_delete_vm_ports_attached_to_network_delete_port_raise_vimconnexception(
4538 self
, mock_delete_ports_by_id_wth_neutron
4540 """_delete_ports_by_id_wth_neutron raises vimconnexception."""
4541 created_items
= deepcopy(created_items_all_true
)
4542 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
4543 "Can not delete port"
4545 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4546 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4547 self
.vimconn
.logger
.error
.assert_called_once_with(
4548 "Error deleting port: VimConnException: Can not delete port"
4551 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4552 def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
4553 self
, mock_delete_ports_by_id_wth_neutron
4555 """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
4556 created_items
= deepcopy(created_items_all_true
)
4557 mock_delete_ports_by_id_wth_neutron
.side_effect
= nvExceptions
.ClientException(
4558 "Connection aborted."
4560 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4561 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4562 self
.vimconn
.logger
.error
.assert_called_once_with(
4563 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4566 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4567 def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
4568 self
, mock_delete_ports_by_id_wth_neutron
4570 """port item is invalid."""
4572 f
"floating_ip:{floating_network_vim_id}": True,
4573 f
"volume:{volume_id2}": True,
4574 f
"volume:{volume_id}": True,
4575 f
"port:{port_id}:": True,
4577 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
4578 "Port is not valid."
4580 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4581 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}:")
4582 self
.vimconn
.logger
.error
.assert_called_once_with(
4583 "Error deleting port: VimConnException: Port is not valid."
4586 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4587 def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
4588 self
, mock_delete_ports_by_id_wth_neutron
4590 """port is already deleted."""
4592 f
"floating_ip:{floating_network_vim_id}": True,
4593 f
"volume:{volume_id2}": True,
4594 f
"volume:{volume_id}": None,
4595 f
"port:{port_id}": None,
4597 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4598 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4599 self
.vimconn
.logger
.error
.assert_not_called()
4601 def test_delete_floating_ip_by_id(self
):
4603 f
"floating_ip:{floating_network_vim_id}": True,
4604 f
"port:{port_id}": True,
4606 expected_created_items
= {
4607 f
"floating_ip:{floating_network_vim_id}": None,
4608 f
"port:{port_id}": True,
4610 k_id
= floating_network_vim_id
4611 k
= f
"floating_ip:{floating_network_vim_id}"
4612 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4613 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4614 self
.assertEqual(created_items
, expected_created_items
)
4616 def test_delete_floating_ip_by_id_floating_ip_already_deleted(self
):
4617 """floating ip is already deleted."""
4619 f
"floating_ip:{floating_network_vim_id}": None,
4620 f
"port:{port_id}": True,
4622 k_id
= floating_network_vim_id
4623 k
= f
"floating_ip:{floating_network_vim_id}"
4624 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4625 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4629 f
"floating_ip:{floating_network_vim_id}": None,
4630 f
"port:{port_id}": True,
4634 def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self
):
4635 """netron delete floating ip raises nvExceptions.ClientException."""
4637 f
"floating_ip:{floating_network_vim_id}": True,
4638 f
"port:{port_id}": True,
4640 k_id
= floating_network_vim_id
4641 k
= f
"floating_ip:{floating_network_vim_id}"
4642 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= (
4643 nvExceptions
.ClientException("Client exception occurred.")
4645 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4646 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4650 f
"floating_ip:{floating_network_vim_id}": True,
4651 f
"port:{port_id}": True,
4654 self
.vimconn
.logger
.error
.assert_called_once_with(
4655 "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occurred.)"
4658 def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self
):
4659 """netron delete floating ip raises VimConnNotFoundException."""
4661 f
"floating_ip:{floating_network_vim_id}": True,
4662 f
"port:{port_id}": True,
4664 k_id
= floating_network_vim_id
4665 k
= f
"floating_ip:{floating_network_vim_id}"
4666 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= VimConnNotFoundException(
4667 "Port id could not found."
4669 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4670 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4674 f
"floating_ip:{floating_network_vim_id}": True,
4675 f
"port:{port_id}": True,
4678 self
.vimconn
.logger
.error
.assert_called_once_with(
4679 "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
4682 def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self
):
4683 """invalid floating ip item."""
4685 f
"floating_ip:{floating_network_vim_id}": True,
4686 f
"port:{port_id}": True,
4688 expected_created_items
= {
4689 f
"floating_ip:{floating_network_vim_id}::": None,
4690 f
"floating_ip:{floating_network_vim_id}": True,
4691 f
"port:{port_id}": True,
4693 k_id
= floating_network_vim_id
4694 k
= f
"floating_ip:{floating_network_vim_id}::"
4695 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4696 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4697 self
.assertEqual(created_items
, expected_created_items
)
4699 def test_delete_volumes_by_id_with_cinder_volume_status_available(self
):
4700 """volume status is available."""
4702 f
"floating_ip:{floating_network_vim_id}": True,
4703 f
"volume:{volume_id2}": True,
4704 f
"volume:{volume_id}": True,
4705 f
"port:{port_id}": None,
4707 expected_created_items
= {
4708 f
"floating_ip:{floating_network_vim_id}": True,
4709 f
"volume:{volume_id2}": True,
4710 f
"volume:{volume_id}": None,
4711 f
"port:{port_id}": None,
4713 volumes_to_hold
= []
4714 k
= f
"volume:{volume_id}"
4716 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4717 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4718 k
, k_id
, volumes_to_hold
, created_items
4720 self
.assertEqual(result
, None)
4721 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4722 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4723 self
.vimconn
.logger
.error
.assert_not_called()
4724 self
.assertEqual(created_items
, expected_created_items
)
4726 def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self
):
4727 """volume is already deleted."""
4729 f
"floating_ip:{floating_network_vim_id}": True,
4730 f
"volume:{volume_id2}": True,
4731 f
"volume:{volume_id}": None,
4732 f
"port:{port_id}": None,
4734 expected_created_items
= {
4735 f
"floating_ip:{floating_network_vim_id}": True,
4736 f
"volume:{volume_id2}": True,
4737 f
"volume:{volume_id}": None,
4738 f
"port:{port_id}": None,
4740 volumes_to_hold
= []
4741 k
= f
"volume:{volume_id}"
4743 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4744 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4745 k
, k_id
, volumes_to_hold
, created_items
4747 self
.assertEqual(result
, None)
4748 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4749 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4750 self
.vimconn
.logger
.error
.assert_not_called()
4751 self
.assertEqual(created_items
, expected_created_items
)
4753 def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self
):
4754 """cinder get volume raises exception."""
4756 f
"floating_ip:{floating_network_vim_id}": True,
4757 f
"volume:{volume_id2}": True,
4758 f
"volume:{volume_id}": True,
4759 f
"port:{port_id}": None,
4761 expected_created_items
= {
4762 f
"floating_ip:{floating_network_vim_id}": True,
4763 f
"volume:{volume_id2}": True,
4764 f
"volume:{volume_id}": True,
4765 f
"port:{port_id}": None,
4767 volumes_to_hold
= []
4768 k
= f
"volume:{volume_id}"
4770 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception(
4771 "Can not get volume status."
4773 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4774 k
, k_id
, volumes_to_hold
, created_items
4776 self
.assertEqual(result
, None)
4777 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4778 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4779 self
.vimconn
.logger
.error
.assert_called_once_with(
4780 "Error deleting volume: Exception: Can not get volume status."
4782 self
.assertEqual(created_items
, expected_created_items
)
4784 def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self
):
4785 """cinder delete volume raises exception."""
4787 f
"floating_ip:{floating_network_vim_id}": True,
4788 f
"volume:{volume_id2}": True,
4789 f
"volume:{volume_id}": True,
4790 f
"port:{port_id}": None,
4792 expected_created_items
= {
4793 f
"floating_ip:{floating_network_vim_id}": True,
4794 f
"volume:{volume_id2}": True,
4795 f
"volume:{volume_id}": True,
4796 f
"port:{port_id}": None,
4798 volumes_to_hold
= []
4799 k
= f
"volume:{volume_id}"
4801 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4802 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= nvExceptions
.ClientException(
4803 "Connection aborted."
4805 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4806 k
, k_id
, volumes_to_hold
, created_items
4808 self
.assertEqual(result
, None)
4809 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4810 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4811 self
.vimconn
.logger
.error
.assert_called_once_with(
4812 "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
4814 self
.assertEqual(created_items
, expected_created_items
)
4816 def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self
):
4817 """volume_to_hold has item."""
4819 f
"floating_ip:{floating_network_vim_id}": True,
4820 f
"volume:{volume_id2}": True,
4821 f
"volume:{volume_id}": True,
4822 f
"port:{port_id}": None,
4824 expected_created_items
= {
4825 f
"floating_ip:{floating_network_vim_id}": True,
4826 f
"volume:{volume_id2}": True,
4827 f
"volume:{volume_id}": True,
4828 f
"port:{port_id}": None,
4830 volumes_to_hold
= [volume_id
]
4831 k
= f
"volume:{volume_id}"
4833 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4834 k
, k_id
, volumes_to_hold
, created_items
4836 self
.assertEqual(result
, None)
4837 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
4838 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4839 self
.vimconn
.logger
.error
.assert_not_called()
4840 self
.assertEqual(created_items
, expected_created_items
)
4842 def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self
):
4843 """volume status is not available."""
4845 f
"floating_ip:{floating_network_vim_id}": True,
4846 f
"volume:{volume_id2}": True,
4847 f
"volume:{volume_id}": True,
4848 f
"port:{port_id}": None,
4850 expected_created_items
= {
4851 f
"floating_ip:{floating_network_vim_id}": True,
4852 f
"volume:{volume_id2}": True,
4853 f
"volume:{volume_id}": True,
4854 f
"port:{port_id}": None,
4856 volumes_to_hold
= []
4857 k
= f
"volume:{volume_id}"
4859 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "unavailable"
4860 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4861 k
, k_id
, volumes_to_hold
, created_items
4863 self
.assertEqual(result
, True)
4864 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4865 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4866 self
.vimconn
.logger
.error
.assert_not_called()
4867 self
.assertEqual(created_items
, expected_created_items
)
4869 def test_delete_ports_by_id_by_neutron(self
):
4870 """neutron delete ports."""
4872 self
.vimconn
.neutron
.list_ports
.return_value
= {
4873 "ports": [{"id": port_id
}, {"id": port2_id
}]
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_not_called()
4881 def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self
):
4882 """port id not in the port list."""
4884 self
.vimconn
.neutron
.list_ports
.return_value
= {
4885 "ports": [{"id": port_id
}, {"id": port2_id
}]
4888 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4889 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4890 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4891 self
.vimconn
.logger
.error
.assert_not_called()
4893 def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self
):
4894 """neutron list port raises exception."""
4896 self
.vimconn
.neutron
.list_ports
.side_effect
= nvExceptions
.ClientException(
4897 "Connection aborted."
4899 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4900 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4901 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4902 self
.vimconn
.logger
.error
.assert_called_once_with(
4903 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4906 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
4907 """neutron delete port raises exception."""
4909 self
.vimconn
.neutron
.list_ports
.return_value
= {
4910 "ports": [{"id": port_id
}, {"id": port2_id
}]
4912 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
4913 "Connection aborted."
4915 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
4916 self
.vimconn
.neutron
.list_ports
.assert_called_once()
4917 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
4918 self
.vimconn
.logger
.error
.assert_called_once_with(
4919 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4922 def test_get_item_name_id(self
):
4923 """Get name and id successfully."""
4924 k
= f
"some:{port_id}"
4925 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4926 self
.assertEqual(result
, ("some", f
"{port_id}"))
4928 def test_get_item_name_id_wthout_semicolon(self
):
4929 """Does not have seperator."""
4930 k
= f
"some{port_id}"
4931 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4932 self
.assertEqual(result
, (f
"some{port_id}", ""))
4934 def test_get_item_name_id_empty_string(self
):
4937 result
= self
.vimconn
._get
_item
_name
_id
(k
)
4938 self
.assertEqual(result
, ("", ""))
4940 def test_get_item_name_id_k_is_none(self
):
4943 with self
.assertRaises(AttributeError):
4944 self
.vimconn
._get
_item
_name
_id
(k
)
4946 @patch.object(vimconnector
, "_get_item_name_id")
4947 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4948 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4949 def test_delete_created_items(
4951 mock_delete_floating_ip_by_id
,
4952 mock_delete_volumes_by_id_wth_cinder
,
4953 mock_get_item_name_id
,
4955 """Created items has floating ip and volume."""
4957 f
"floating_ip:{floating_network_vim_id}": True,
4958 f
"volume:{volume_id}": True,
4959 f
"port:{port_id}": None,
4961 mock_get_item_name_id
.side_effect
= [
4962 ("floating_ip", f
"{floating_network_vim_id}"),
4963 ("volume", f
"{volume_id}"),
4965 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
4966 volumes_to_hold
= []
4967 keep_waiting
= False
4968 result
= self
.vimconn
._delete
_created
_items
(
4969 created_items
, volumes_to_hold
, keep_waiting
4971 self
.assertEqual(result
, True)
4972 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
4973 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
4974 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
4976 mock_delete_floating_ip_by_id
.assert_called_once_with(
4977 f
"floating_ip:{floating_network_vim_id}",
4978 f
"{floating_network_vim_id}",
4981 self
.vimconn
.logger
.error
.assert_not_called()
4983 @patch.object(vimconnector
, "_get_item_name_id")
4984 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
4985 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
4986 def test_delete_created_items_wth_volumes_to_hold(
4988 mock_delete_floating_ip_by_id
,
4989 mock_delete_volumes_by_id_wth_cinder
,
4990 mock_get_item_name_id
,
4992 """Created items has floating ip and volume and volumes_to_hold has items."""
4994 f
"floating_ip:{floating_network_vim_id}": True,
4995 f
"volume:{volume_id}": True,
4996 f
"port:{port_id}": None,
4998 mock_get_item_name_id
.side_effect
= [
4999 ("floating_ip", f
"{floating_network_vim_id}"),
5000 ("volume", f
"{volume_id}"),
5002 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
5003 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5004 keep_waiting
= False
5005 result
= self
.vimconn
._delete
_created
_items
(
5006 created_items
, volumes_to_hold
, keep_waiting
5008 self
.assertEqual(result
, True)
5009 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5010 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5011 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
5013 mock_delete_floating_ip_by_id
.assert_called_once_with(
5014 f
"floating_ip:{floating_network_vim_id}",
5015 f
"{floating_network_vim_id}",
5018 self
.vimconn
.logger
.error
.assert_not_called()
5020 @patch.object(vimconnector
, "_get_item_name_id")
5021 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5022 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5023 def test_delete_created_items_wth_keep_waiting_true(
5025 mock_delete_floating_ip_by_id
,
5026 mock_delete_volumes_by_id_wth_cinder
,
5027 mock_get_item_name_id
,
5029 """Keep waiting initial value is True."""
5031 f
"floating_ip:{floating_network_vim_id}": True,
5032 f
"volume:{volume_id}": True,
5033 f
"port:{port_id}": None,
5035 mock_get_item_name_id
.side_effect
= [
5036 ("floating_ip", f
"{floating_network_vim_id}"),
5037 ("volume", f
"{volume_id}"),
5039 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5040 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5042 result
= self
.vimconn
._delete
_created
_items
(
5043 created_items
, volumes_to_hold
, keep_waiting
5045 self
.assertEqual(result
, True)
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}", volumes_to_hold
, 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_not_called()
5057 @patch.object(vimconnector
, "_get_item_name_id")
5058 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5059 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5060 def test_delete_created_items_delete_vol_raises(
5062 mock_delete_floating_ip_by_id
,
5063 mock_delete_volumes_by_id_wth_cinder
,
5064 mock_get_item_name_id
,
5066 """Delete volume raises exception."""
5068 f
"floating_ip:{floating_network_vim_id}": True,
5069 f
"volume:{volume_id}": True,
5070 f
"port:{port_id}": None,
5072 mock_get_item_name_id
.side_effect
= [
5073 ("floating_ip", f
"{floating_network_vim_id}"),
5074 ("volume", f
"{volume_id}"),
5076 mock_delete_volumes_by_id_wth_cinder
.side_effect
= ConnectionError(
5077 "Connection failed."
5079 volumes_to_hold
= []
5080 keep_waiting
= False
5081 result
= self
.vimconn
._delete
_created
_items
(
5082 created_items
, volumes_to_hold
, keep_waiting
5084 self
.assertEqual(result
, False)
5085 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5086 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5087 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5089 mock_delete_floating_ip_by_id
.assert_called_once_with(
5090 f
"floating_ip:{floating_network_vim_id}",
5091 f
"{floating_network_vim_id}",
5094 self
.vimconn
.logger
.error
.assert_called_once_with(
5095 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
5098 @patch.object(vimconnector
, "_get_item_name_id")
5099 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5100 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5101 def test_delete_created_items_delete_fip_raises(
5103 mock_delete_floating_ip_by_id
,
5104 mock_delete_volumes_by_id_wth_cinder
,
5105 mock_get_item_name_id
,
5107 """Delete floating ip raises exception."""
5109 f
"floating_ip:{floating_network_vim_id}": True,
5110 f
"volume:{volume_id}": True,
5111 f
"port:{port_id}": None,
5113 mock_get_item_name_id
.side_effect
= [
5114 ("floating_ip", f
"{floating_network_vim_id}"),
5115 ("volume", f
"{volume_id}"),
5117 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5118 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
5119 "Connection failed."
5121 volumes_to_hold
= []
5123 result
= self
.vimconn
._delete
_created
_items
(
5124 created_items
, volumes_to_hold
, keep_waiting
5126 self
.assertEqual(result
, True)
5127 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5128 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5129 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5131 mock_delete_floating_ip_by_id
.assert_called_once_with(
5132 f
"floating_ip:{floating_network_vim_id}",
5133 f
"{floating_network_vim_id}",
5136 self
.vimconn
.logger
.error
.assert_called_once_with(
5137 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
5140 @patch.object(vimconnector
, "_get_item_name_id")
5141 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5142 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5143 def test_delete_created_items_get_item_name_raises(
5145 mock_delete_floating_ip_by_id
,
5146 mock_delete_volumes_by_id_wth_cinder
,
5147 mock_get_item_name_id
,
5149 """Get item, name raises exception."""
5152 f
"volume{volume_id}": True,
5153 f
"port:{port_id}": None,
5155 mock_get_item_name_id
.side_effect
= [
5156 TypeError("Invalid Type"),
5157 AttributeError("Invalid attribute"),
5159 volumes_to_hold
= []
5160 keep_waiting
= False
5161 result
= self
.vimconn
._delete
_created
_items
(
5162 created_items
, volumes_to_hold
, keep_waiting
5164 self
.assertEqual(result
, False)
5165 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5166 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5167 mock_delete_floating_ip_by_id
.assert_not_called()
5168 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
5169 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
5172 (f
"Error deleting volume{volume_id}: Invalid attribute",),
5175 @patch.object(vimconnector
, "_get_item_name_id")
5176 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5177 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5178 def test_delete_created_items_no_fip_wth_port(
5180 mock_delete_floating_ip_by_id
,
5181 mock_delete_volumes_by_id_wth_cinder
,
5182 mock_get_item_name_id
,
5184 """Created items has port, does not have floating ip."""
5186 f
"volume:{volume_id}": True,
5187 f
"port:{port_id}": True,
5189 mock_get_item_name_id
.side_effect
= [
5190 ("volume", f
"{volume_id}"),
5191 ("port", f
"{port_id}"),
5193 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5194 volumes_to_hold
= []
5195 keep_waiting
= False
5196 result
= self
.vimconn
._delete
_created
_items
(
5197 created_items
, volumes_to_hold
, keep_waiting
5199 self
.assertEqual(result
, False)
5200 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5201 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5202 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5204 mock_delete_floating_ip_by_id
.assert_not_called()
5205 self
.vimconn
.logger
.error
.assert_not_called()
5207 @patch.object(vimconnector
, "_get_item_name_id")
5208 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5209 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5210 def test_delete_created_items_no_volume(
5212 mock_delete_floating_ip_by_id
,
5213 mock_delete_volumes_by_id_wth_cinder
,
5214 mock_get_item_name_id
,
5216 """Created items does not have volume."""
5218 f
"floating_ip:{floating_network_vim_id}": True,
5219 f
"port:{port_id}": None,
5221 mock_get_item_name_id
.side_effect
= [
5222 ("floating_ip", f
"{floating_network_vim_id}")
5224 volumes_to_hold
= []
5225 keep_waiting
= False
5226 result
= self
.vimconn
._delete
_created
_items
(
5227 created_items
, volumes_to_hold
, keep_waiting
5229 self
.assertEqual(result
, False)
5230 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
5231 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5232 mock_delete_floating_ip_by_id
.assert_called_once_with(
5233 f
"floating_ip:{floating_network_vim_id}",
5234 f
"{floating_network_vim_id}",
5237 self
.vimconn
.logger
.error
.assert_not_called()
5239 @patch.object(vimconnector
, "_get_item_name_id")
5240 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5241 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5242 def test_delete_created_items_already_deleted(
5244 mock_delete_floating_ip_by_id
,
5245 mock_delete_volumes_by_id_wth_cinder
,
5246 mock_get_item_name_id
,
5248 """All created items are alerady deleted."""
5250 f
"floating_ip:{floating_network_vim_id}": None,
5251 f
"volume:{volume_id}": None,
5252 f
"port:{port_id}": None,
5254 volumes_to_hold
= []
5255 keep_waiting
= False
5256 result
= self
.vimconn
._delete
_created
_items
(
5257 created_items
, volumes_to_hold
, keep_waiting
5259 self
.assertEqual(result
, False)
5260 mock_get_item_name_id
.assert_not_called()
5261 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5262 mock_delete_floating_ip_by_id
.assert_not_called()
5263 self
.vimconn
.logger
.error
.assert_not_called()
5265 @patch("time.sleep")
5266 @patch.object(vimconnector
, "_format_exception")
5267 @patch.object(vimconnector
, "_reload_connection")
5268 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5269 @patch.object(vimconnector
, "_delete_created_items")
5270 def test_delete_vminstance_successfully(
5272 mock_delete_created_items
,
5273 mock_delete_vm_ports_attached_to_network
,
5274 mock_reload_connection
,
5275 mock_format_exception
,
5278 vm_id
= f
"{virtual_mac_id}"
5279 created_items
= deepcopy(created_items_all_true
)
5280 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5281 mock_delete_created_items
.return_value
= False
5282 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5283 mock_reload_connection
.assert_called_once()
5284 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5285 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5286 mock_delete_created_items
.assert_called_once_with(
5287 created_items
, volumes_to_hold
, False
5289 mock_sleep
.assert_not_called()
5290 mock_format_exception
.assert_not_called()
5292 @patch("time.sleep")
5293 @patch.object(vimconnector
, "_format_exception")
5294 @patch.object(vimconnector
, "_reload_connection")
5295 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5296 @patch.object(vimconnector
, "_delete_created_items")
5297 def test_delete_vminstance_delete_created_items_raises(
5299 mock_delete_created_items
,
5300 mock_delete_vm_ports_attached_to_network
,
5301 mock_reload_connection
,
5302 mock_format_exception
,
5305 """Delete creted items raises exception."""
5306 vm_id
= f
"{virtual_mac_id}"
5307 created_items
= deepcopy(created_items_all_true
)
5308 mock_sleep
= MagicMock()
5309 volumes_to_hold
= []
5310 err
= ConnectionError("ClientException occurred.")
5311 mock_delete_created_items
.side_effect
= err
5312 with self
.assertRaises(ConnectionError
) as err
:
5313 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5314 self
.assertEqual(str(err
), "ClientException occurred.")
5315 mock_reload_connection
.assert_called_once()
5316 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5317 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5318 mock_delete_created_items
.assert_called_once()
5319 mock_sleep
.assert_not_called()
5321 @patch("time.sleep")
5322 @patch.object(vimconnector
, "_format_exception")
5323 @patch.object(vimconnector
, "_reload_connection")
5324 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5325 @patch.object(vimconnector
, "_delete_created_items")
5326 def test_delete_vminstance_delete_vm_ports_raises(
5328 mock_delete_created_items
,
5329 mock_delete_vm_ports_attached_to_network
,
5330 mock_reload_connection
,
5331 mock_format_exception
,
5334 """Delete vm ports raises exception."""
5335 vm_id
= f
"{virtual_mac_id}"
5336 created_items
= deepcopy(created_items_all_true
)
5337 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5338 err
= ConnectionError("ClientException occurred.")
5339 mock_delete_vm_ports_attached_to_network
.side_effect
= err
5340 mock_delete_created_items
.side_effect
= err
5341 with self
.assertRaises(ConnectionError
) as err
:
5342 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5343 self
.assertEqual(str(err
), "ClientException occurred.")
5344 mock_reload_connection
.assert_called_once()
5345 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5346 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5347 mock_delete_created_items
.assert_not_called()
5348 mock_sleep
.assert_not_called()
5350 @patch("time.sleep")
5351 @patch.object(vimconnector
, "_format_exception")
5352 @patch.object(vimconnector
, "_reload_connection")
5353 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5354 @patch.object(vimconnector
, "_delete_created_items")
5355 def test_delete_vminstance_nova_server_delete_raises(
5357 mock_delete_created_items
,
5358 mock_delete_vm_ports_attached_to_network
,
5359 mock_reload_connection
,
5360 mock_format_exception
,
5363 """Nova server delete raises exception."""
5364 vm_id
= f
"{virtual_mac_id}"
5365 created_items
= deepcopy(created_items_all_true
)
5366 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5367 err
= VimConnConnectionException("ClientException occurred.")
5368 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
5369 mock_delete_created_items
.side_effect
= err
5370 with self
.assertRaises(VimConnConnectionException
) as err
:
5371 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5372 self
.assertEqual(str(err
), "ClientException occurred.")
5373 mock_reload_connection
.assert_called_once()
5374 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5375 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5376 mock_delete_created_items
.assert_not_called()
5377 mock_sleep
.assert_not_called()
5379 @patch("time.sleep")
5380 @patch.object(vimconnector
, "_format_exception")
5381 @patch.object(vimconnector
, "_reload_connection")
5382 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5383 @patch.object(vimconnector
, "_delete_created_items")
5384 def test_delete_vminstance_reload_connection_raises(
5386 mock_delete_created_items
,
5387 mock_delete_vm_ports_attached_to_network
,
5388 mock_reload_connection
,
5389 mock_format_exception
,
5392 """Reload connection raises exception."""
5393 vm_id
= f
"{virtual_mac_id}"
5394 created_items
= deepcopy(created_items_all_true
)
5395 mock_sleep
= MagicMock()
5396 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5397 err
= ConnectionError("ClientException occurred.")
5398 mock_delete_created_items
.return_value
= False
5399 mock_reload_connection
.side_effect
= err
5400 with self
.assertRaises(ConnectionError
) as err
:
5401 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5402 self
.assertEqual(str(err
), "ClientException occurred.")
5403 mock_reload_connection
.assert_called_once()
5404 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5405 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5406 mock_delete_created_items
.assert_not_called()
5407 mock_sleep
.assert_not_called()
5409 @patch("time.sleep")
5410 @patch.object(vimconnector
, "_format_exception")
5411 @patch.object(vimconnector
, "_reload_connection")
5412 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5413 @patch.object(vimconnector
, "_delete_created_items")
5414 def test_delete_vminstance_created_item_vol_to_hold_are_none(
5416 mock_delete_created_items
,
5417 mock_delete_vm_ports_attached_to_network
,
5418 mock_reload_connection
,
5419 mock_format_exception
,
5422 """created_items and volumes_to_hold are None."""
5423 vm_id
= f
"{virtual_mac_id}"
5424 created_items
= None
5425 volumes_to_hold
= None
5426 mock_delete_created_items
.return_value
= False
5427 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5428 mock_reload_connection
.assert_called_once()
5429 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5430 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5431 mock_delete_created_items
.assert_called_once_with({}, [], False)
5432 mock_sleep
.assert_not_called()
5433 mock_format_exception
.assert_not_called()
5435 @patch("time.sleep")
5436 @patch.object(vimconnector
, "_format_exception")
5437 @patch.object(vimconnector
, "_reload_connection")
5438 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5439 @patch.object(vimconnector
, "_delete_created_items")
5440 def test_delete_vminstance_vm_id_is_none(
5442 mock_delete_created_items
,
5443 mock_delete_vm_ports_attached_to_network
,
5444 mock_reload_connection
,
5445 mock_format_exception
,
5448 """vm_id is None."""
5450 created_items
= deepcopy(created_items_all_true
)
5451 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5452 mock_delete_created_items
.side_effect
= [True, True, False]
5453 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5454 mock_reload_connection
.assert_called_once()
5455 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5456 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5457 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
5458 self
.assertEqual(mock_sleep
.call_count
, 2)
5459 mock_format_exception
.assert_not_called()
5461 @patch("time.sleep")
5462 @patch.object(vimconnector
, "_format_exception")
5463 @patch.object(vimconnector
, "_reload_connection")
5464 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5465 @patch.object(vimconnector
, "_delete_created_items")
5466 def test_delete_vminstance_delete_created_items_return_true(
5468 mock_delete_created_items
,
5469 mock_delete_vm_ports_attached_to_network
,
5470 mock_reload_connection
,
5471 mock_format_exception
,
5474 """Delete created items always return True."""
5476 created_items
= deepcopy(created_items_all_true
)
5477 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5478 mock_delete_created_items
.side_effect
= [True] * 1800
5479 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5480 mock_reload_connection
.assert_called_once()
5481 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5482 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5483 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
5484 self
.assertEqual(mock_sleep
.call_count
, 1800)
5485 mock_format_exception
.assert_not_called()
5487 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5488 def test_get_monitoring_data(self
, mock_reload_conection
):
5489 servers
= ["server1", "server2"]
5490 ports
= {"ports": ["port1", "port2"]}
5491 self
.vimconn
.nova
.servers
.list.return_value
= servers
5492 self
.vimconn
.neutron
.list_ports
.return_value
= ports
5493 result
= self
.vimconn
.get_monitoring_data()
5494 self
.assertTupleEqual(result
, (servers
, ports
))
5495 mock_reload_conection
.assert_called_once()
5496 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5497 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5499 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5500 def test_get_monitoring_data_reload_connection_raises(self
, mock_reload_conection
):
5501 mock_reload_conection
.side_effect
= VimConnNotFoundException(
5502 "Connection object not found."
5504 with self
.assertRaises(VimConnException
) as err
:
5505 result
= self
.vimconn
.get_monitoring_data()
5506 self
.assertTupleEqual(result
, None)
5508 str(err
.exception
.args
[0]),
5509 "Exception in monitoring while getting VMs and ports status: Connection object not found.",
5511 mock_reload_conection
.assert_called_once()
5512 check_if_assert_not_called(
5513 [self
.vimconn
.nova
.servers
.list, self
.vimconn
.neutron
.list_ports
]
5516 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5517 def test_get_monitoring_data_server_list_raises(self
, mock_reload_conection
):
5518 self
.vimconn
.nova
.servers
.list.side_effect
= VimConnConnectionException(
5519 "Can not connect to Cloud API."
5521 with self
.assertRaises(VimConnException
) as err
:
5522 result
= self
.vimconn
.get_monitoring_data()
5523 self
.assertTupleEqual(result
, None)
5525 str(err
.exception
.args
[0]),
5526 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5528 mock_reload_conection
.assert_called_once()
5529 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5530 self
.vimconn
.neutron
.list_ports
.assert_not_called()
5532 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
5533 def test_get_monitoring_data_list_ports_raises(self
, mock_reload_conection
):
5534 self
.vimconn
.neutron
.list_ports
.side_effect
= VimConnConnectionException(
5535 "Can not connect to Cloud API."
5537 with self
.assertRaises(VimConnException
) as err
:
5538 result
= self
.vimconn
.get_monitoring_data()
5539 self
.assertTupleEqual(result
, None)
5541 str(err
.exception
.args
[0]),
5542 "Exception in monitoring while getting VMs and ports status: Can not connect to Cloud API.",
5544 mock_reload_conection
.assert_called_once()
5545 self
.vimconn
.nova
.servers
.list.assert_called_once_with(detailed
=True)
5546 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5549 class TestNewFlavor(unittest
.TestCase
):
5550 @patch("logging.getLogger", autospec
=True)
5551 def setUp(self
, mock_logger
):
5552 # We are disabling the logging of exception not to print them to console.
5553 mock_logger
= logging
.getLogger()
5554 mock_logger
.disabled
= True
5555 self
.vimconn
= vimconnector(
5565 self
.vimconn
.nova
= CopyingMock(autospec
=True)
5566 self
.flavor1
= CopyingMock(autospec
=True, name
="sample-flavor")
5567 self
.flavor2
= CopyingMock(autospec
=True, name
="other-flavor")
5568 self
.new_flavor
= CopyingMock(autospec
=True, name
="new_flavor")
5569 self
.new_flavor
.id = "075d2482-5edb-43e3-91b3-234e65b6268a"
5570 self
.vimconn
.nova
.flavors
.create
.return_value
= self
.new_flavor
5572 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5573 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5574 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5577 "process_numa_paired_threads",
5578 new_callable
=CopyingMock(),
5580 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5581 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5582 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_vio(
5584 mock_process_numa_threads
,
5585 mock_process_numa_cores
,
5586 mock_process_numa_paired_threads
,
5587 mock_process_numa_vcpu
,
5588 mock_process_numa_memory
,
5589 mock_process_vio_numa_nodes
,
5591 """Process numa parameters, id, memory, vcpu exist, vim type is VIO,
5592 paired-threads, cores, threads do not exist in numa.
5595 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5596 {"id": 1, "memory": 2, "vcpu": [2]},
5599 expected_extra_specs
= {
5600 "hw:numa_nodes": "2",
5601 "hw:cpu_sockets": "2",
5603 self
.vimconn
.vim_type
= "VIO"
5604 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5606 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5607 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5608 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5609 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5611 _call_mock_process_numa_memory
[0].args
,
5613 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5616 "hw:numa_nodes": "2",
5621 _call_mock_process_numa_memory
[1].args
,
5623 {"id": 1, "memory": 2, "vcpu": [2]},
5626 "hw:cpu_sockets": "2",
5627 "hw:numa_nodes": "2",
5631 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5633 _call_mock_process_numa_vcpu
[0].args
,
5635 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5638 "hw:numa_nodes": "2",
5643 _call_mock_process_numa_vcpu
[1].args
,
5645 {"id": 1, "memory": 2, "vcpu": [2]},
5648 "hw:cpu_sockets": "2",
5649 "hw:numa_nodes": "2",
5653 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5654 check_if_assert_not_called(
5656 mock_process_numa_threads
,
5657 mock_process_numa_cores
,
5658 mock_process_numa_paired_threads
,
5662 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5663 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5664 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5667 "process_numa_paired_threads",
5668 new_callable
=CopyingMock(),
5670 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5671 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5672 def test_process_numa_parameters_of_flavor_id_memory_vcpu_in_numa_type_openstack(
5674 mock_process_numa_threads
,
5675 mock_process_numa_cores
,
5676 mock_process_numa_paired_threads
,
5677 mock_process_numa_vcpu
,
5678 mock_process_numa_memory
,
5679 mock_process_vio_numa_nodes
,
5681 """Process numa parameters, id, memory, vcpu exist, vim type is openstack,
5682 paired-threads, cores, threads do not exist in numa.
5685 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5686 {"id": 1, "memory": 2, "vcpu": [2]},
5689 expected_extra_specs
= {
5690 "hw:numa_nodes": "2",
5691 "hw:cpu_sockets": "2",
5693 self
.vimconn
.vim_type
= "openstack"
5694 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5696 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5697 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5698 _call_mock_process_numa_memory
= mock_process_numa_memory
.call_args_list
5700 _call_mock_process_numa_memory
[0].args
,
5702 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5704 {"hw:numa_nodes": "2"},
5708 _call_mock_process_numa_memory
[1].args
,
5710 {"id": 1, "memory": 2, "vcpu": [2]},
5712 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5715 _call_mock_process_numa_vcpu
= mock_process_numa_vcpu
.call_args_list
5717 _call_mock_process_numa_vcpu
[0].args
,
5719 {"id": 0, "memory": 1, "vcpu": [1, 3]},
5721 {"hw:numa_nodes": "2"},
5725 _call_mock_process_numa_vcpu
[1].args
,
5727 {"id": 1, "memory": 2, "vcpu": [2]},
5729 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
5732 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5733 check_if_assert_not_called(
5735 mock_process_numa_threads
,
5736 mock_process_numa_cores
,
5737 mock_process_numa_paired_threads
,
5741 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5742 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5743 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5746 "process_numa_paired_threads",
5747 new_callable
=CopyingMock(),
5749 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5750 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5751 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_openstack_extra_spec_not_empty(
5753 mock_process_numa_threads
,
5754 mock_process_numa_cores
,
5755 mock_process_numa_paired_threads
,
5756 mock_process_numa_vcpu
,
5757 mock_process_numa_memory
,
5758 mock_process_vio_numa_nodes
,
5760 """Process numa parameters, id, paired-threads exist, vim type is openstack.
5761 vcpus calculation according to paired-threads in numa, there is extra_spec.
5763 numas
= [{"id": 0, "paired-threads": 3}, {"id": 1, "paired-threads": 3}]
5764 extra_specs
= {"some-key": "some-value"}
5765 expected_extra_specs
= {
5766 "hw:cpu_sockets": "2",
5767 "hw:cpu_threads": "12",
5768 "hw:numa_nodes": "2",
5769 "some-key": "some-value",
5771 self
.vimconn
.vim_type
= "openstack"
5772 mock_process_numa_paired_threads
.side_effect
= [6, 6]
5773 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5775 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5776 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5777 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5778 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5779 _call_mock_process_numa_paired_threads
= (
5780 mock_process_numa_paired_threads
.call_args_list
5783 _call_mock_process_numa_paired_threads
[0].args
,
5785 {"id": 0, "paired-threads": 3},
5786 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5790 _call_mock_process_numa_paired_threads
[1].args
,
5792 {"id": 1, "paired-threads": 3},
5793 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2", "some-key": "some-value"},
5796 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5798 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5799 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5800 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5803 "process_numa_paired_threads",
5804 new_callable
=CopyingMock(),
5806 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5807 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5808 def test_process_numa_parameters_of_flavor_id_paired_threads_in_numa_type_vio_extra_spec_not_empty(
5810 mock_process_numa_threads
,
5811 mock_process_numa_cores
,
5812 mock_process_numa_paired_threads
,
5813 mock_process_numa_vcpu
,
5814 mock_process_numa_memory
,
5815 mock_process_vio_numa_nodes
,
5817 """Process numa parameters, id, paired-threads exist, vim type is VIO.
5818 vcpus calculation according to paired-threads in numa, there is extra_spec.
5820 numas
= [{"id": 0, "paired-threads": 2}, {"id": 1, "paired-threads": 2}]
5821 extra_specs
= {"some-key": "some-value"}
5822 expected_extra_specs
= {
5823 "hw:numa_nodes": "2",
5824 "hw:cpu_sockets": "2",
5825 "hw:cpu_threads": "8",
5826 "some-key": "some-value",
5828 self
.vimconn
.vim_type
= "VIO"
5829 mock_process_numa_paired_threads
.side_effect
= [4, 4]
5830 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5831 check_if_assert_not_called([mock_process_numa_threads
, mock_process_numa_cores
])
5832 self
.assertEqual(mock_process_numa_paired_threads
.call_count
, 2)
5833 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5834 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5835 _call_mock_process_numa_paired_threads
= (
5836 mock_process_numa_paired_threads
.call_args_list
5838 mock_process_vio_numa_nodes
.assert_called_once_with(
5839 2, {"some-key": "some-value", "hw:numa_nodes": "2"}
5842 _call_mock_process_numa_paired_threads
[0].args
,
5844 {"id": 0, "paired-threads": 2},
5846 "hw:cpu_sockets": "2",
5847 "hw:numa_nodes": "2",
5848 "some-key": "some-value",
5853 _call_mock_process_numa_paired_threads
[1].args
,
5855 {"id": 1, "paired-threads": 2},
5857 "hw:cpu_sockets": "2",
5858 "hw:numa_nodes": "2",
5859 "some-key": "some-value",
5863 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5865 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5866 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5867 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5870 "process_numa_paired_threads",
5871 new_callable
=CopyingMock(),
5873 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5874 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5875 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_openstack(
5877 mock_process_numa_threads
,
5878 mock_process_numa_cores
,
5879 mock_process_numa_paired_threads
,
5880 mock_process_numa_vcpu
,
5881 mock_process_numa_memory
,
5882 mock_process_vio_numa_nodes
,
5884 """Process numa parameters, id, cores exist, vim type is openstack.
5885 vcpus calculation according to cores in numa.
5887 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5889 updated_extra_specs
= {"hw:numa_nodes": "2", "hw:cpu_sockets": "2"}
5890 expected_extra_specs
= {
5891 "hw:numa_nodes": "2",
5892 "hw:cpu_sockets": "2",
5893 "hw:cpu_cores": "3",
5895 self
.vimconn
.vim_type
= "openstack"
5896 mock_process_numa_cores
.side_effect
= [1, 2]
5897 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5899 check_if_assert_not_called(
5900 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5902 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5903 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5904 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5905 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5907 _call_mock_process_numa_cores
[0].args
,
5908 ({"id": 0, "cores": 1}, updated_extra_specs
),
5911 _call_mock_process_numa_cores
[1].args
,
5912 ({"id": 1, "cores": 2}, updated_extra_specs
),
5914 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5916 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5917 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5918 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5921 "process_numa_paired_threads",
5922 new_callable
=CopyingMock(),
5924 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5925 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5926 def test_process_numa_parameters_of_flavor_id_cores_in_numa_type_vio(
5928 mock_process_numa_threads
,
5929 mock_process_numa_cores
,
5930 mock_process_numa_paired_threads
,
5931 mock_process_numa_vcpu
,
5932 mock_process_numa_memory
,
5933 mock_process_vio_numa_nodes
,
5935 """Process numa parameters, id, cores exist, vim type is VIO.
5936 vcpus calculation according to cores in numa.
5938 numas
= [{"id": 0, "cores": 1}, {"id": 1, "cores": 2}]
5940 expected_extra_specs
= {
5941 "hw:cpu_cores": "3",
5942 "hw:cpu_sockets": "2",
5943 "hw:numa_nodes": "2",
5945 self
.vimconn
.vim_type
= "VIO"
5946 mock_process_numa_cores
.side_effect
= [1, 2]
5947 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
5948 check_if_assert_not_called(
5949 [mock_process_numa_threads
, mock_process_numa_paired_threads
]
5951 self
.assertEqual(mock_process_numa_memory
.call_count
, 2)
5952 self
.assertEqual(mock_process_numa_vcpu
.call_count
, 2)
5953 self
.assertEqual(mock_process_numa_cores
.call_count
, 2)
5954 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
5955 _call_mock_process_numa_cores
= mock_process_numa_cores
.call_args_list
5957 _call_mock_process_numa_cores
[0].args
,
5959 {"id": 0, "cores": 1},
5961 "hw:cpu_sockets": "2",
5962 "hw:numa_nodes": "2",
5967 _call_mock_process_numa_cores
[1].args
,
5969 {"id": 1, "cores": 2},
5971 "hw:cpu_sockets": "2",
5972 "hw:numa_nodes": "2",
5976 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
5978 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
5979 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
5980 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
5983 "process_numa_paired_threads",
5984 new_callable
=CopyingMock(),
5986 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
5987 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
5988 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_vio(
5990 mock_process_numa_threads
,
5991 mock_process_numa_cores
,
5992 mock_process_numa_paired_threads
,
5993 mock_process_numa_vcpu
,
5994 mock_process_numa_memory
,
5995 mock_process_vio_numa_nodes
,
5997 """Process numa parameters, memory, vcpu, thread exist, vim type is VIO,
5998 vcpus calculation according threads in numa, there are not numa ids.
6001 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6002 {"memory": 2, "vcpu": [2]},
6005 expected_extra_specs
= {
6006 "hw:numa_nodes": "2",
6007 "hw:cpu_sockets": "2",
6008 "hw:cpu_threads": "3",
6010 self
.vimconn
.vim_type
= "VIO"
6011 mock_process_numa_threads
.return_value
= 3
6012 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
6013 check_if_assert_not_called(
6015 mock_process_numa_memory
,
6016 mock_process_numa_vcpu
,
6017 mock_process_numa_cores
,
6018 mock_process_numa_paired_threads
,
6021 mock_process_vio_numa_nodes
.assert_called_once_with(2, {"hw:numa_nodes": "2"})
6022 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
6023 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
6025 _call_mock_process_numa_threads
[0].args
,
6027 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6029 "hw:cpu_sockets": "2",
6030 "hw:numa_nodes": "2",
6034 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
6036 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
6037 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
6038 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
6041 "process_numa_paired_threads",
6042 new_callable
=CopyingMock(autospec
=True),
6044 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
6045 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
6046 def test_process_numa_parameters_of_flavor_without_numa_id_with_threads_type_openstack(
6048 mock_process_numa_threads
,
6049 mock_process_numa_cores
,
6050 mock_process_numa_paired_threads
,
6051 mock_process_numa_vcpu
,
6052 mock_process_numa_memory
,
6053 mock_process_vio_numa_nodes
,
6055 """Process numa parameters, memory, vcpu, thread exist, vim type is openstack,
6056 vcpus calculation according threads in numa, there are not numa ids.
6059 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6060 {"memory": 2, "vcpu": [2]},
6063 expected_extra_specs
= {
6064 "hw:numa_nodes": "2",
6065 "hw:cpu_sockets": "2",
6066 "hw:cpu_threads": "3",
6068 self
.vimconn
.vim_type
= "openstack"
6069 mock_process_numa_threads
.return_value
= 3
6070 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
6072 check_if_assert_not_called(
6074 mock_process_numa_memory
,
6075 mock_process_numa_vcpu
,
6076 mock_process_numa_cores
,
6077 mock_process_numa_paired_threads
,
6078 mock_process_vio_numa_nodes
,
6081 self
.assertEqual(mock_process_numa_threads
.call_count
, 1)
6082 _call_mock_process_numa_threads
= mock_process_numa_threads
.call_args_list
6084 _call_mock_process_numa_threads
[0].args
,
6086 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6087 {"hw:cpu_sockets": "2", "hw:numa_nodes": "2"},
6090 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
6092 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
6093 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
6094 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
6097 "process_numa_paired_threads",
6098 new_callable
=CopyingMock(),
6100 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
6101 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
6102 def test_process_numa_parameters_of_flavor_empty_numas_list_type_vio(
6104 mock_process_numa_threads
,
6105 mock_process_numa_cores
,
6106 mock_process_numa_paired_threads
,
6107 mock_process_numa_vcpu
,
6108 mock_process_numa_memory
,
6109 mock_process_vio_numa_nodes
,
6111 """Numa list is empty, vim type is VIO."""
6114 expected_extra_specs
= {"hw:numa_nodes": "0"}
6115 self
.vimconn
.vim_type
= "VIO"
6116 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
6117 check_if_assert_not_called(
6119 mock_process_numa_memory
,
6120 mock_process_numa_vcpu
,
6121 mock_process_numa_cores
,
6122 mock_process_numa_paired_threads
,
6123 mock_process_numa_threads
,
6126 mock_process_vio_numa_nodes
.assert_called_once_with(0, {"hw:numa_nodes": "0"})
6127 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
6129 @patch.object(vimconnector
, "process_vio_numa_nodes", new_callable
=CopyingMock())
6130 @patch.object(vimconnector
, "process_numa_memory", new_callable
=CopyingMock())
6131 @patch.object(vimconnector
, "process_numa_vcpu", new_callable
=CopyingMock())
6134 "process_numa_paired_threads",
6135 new_callable
=CopyingMock(),
6137 @patch.object(vimconnector
, "process_numa_cores", new_callable
=CopyingMock())
6138 @patch.object(vimconnector
, "process_numa_threads", new_callable
=CopyingMock())
6139 def test_process_numa_parameters_of_flavor_empty_numas_list_type_openstack(
6141 mock_process_numa_threads
,
6142 mock_process_numa_cores
,
6143 mock_process_numa_paired_threads
,
6144 mock_process_numa_vcpu
,
6145 mock_process_numa_memory
,
6146 mock_process_vio_numa_nodes
,
6148 """Numa list is empty, vim type is openstack."""
6151 expected_extra_specs
= {"hw:numa_nodes": "0"}
6152 self
.vimconn
.vim_type
= "openstack"
6153 mock_process_numa_threads
.return_value
= None
6154 self
.vimconn
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
6156 check_if_assert_not_called(
6158 mock_process_numa_memory
,
6159 mock_process_numa_vcpu
,
6160 mock_process_numa_cores
,
6161 mock_process_numa_paired_threads
,
6162 mock_process_numa_threads
,
6163 mock_process_vio_numa_nodes
,
6166 self
.assertDictEqual(extra_specs
, expected_extra_specs
)
6168 def test_process_numa_memory_empty_extra_spec(self
):
6169 numa
= {"memory": 2, "vcpu": [2]}
6172 expected_extra_spec
= {"hw:numa_mem.2": 2048}
6173 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
6174 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6176 def test_process_numa_memory_not_exist(self
):
6177 numa
= {"vcpu": [2]}
6179 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
6180 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
6181 self
.assertDictEqual(extra_specs
, {"vmware:latency_sensitivity_level": "high"})
6183 def test_process_numa_memory_node_id_is_none(self
):
6184 numa
= {"memory": 2, "vcpu": [2]}
6187 expected_extra_spec
= {"hw:numa_mem.None": 2048}
6188 self
.vimconn
.process_numa_memory(numa
, node_id
, extra_specs
)
6189 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6191 def test_process_numa_vcpu_empty_extra_spec(self
):
6192 numa
= {"vcpu": [2]}
6195 expected_extra_spec
= {"hw:numa_cpus.0": "2"}
6196 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6197 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6199 def test_process_numa_vcpu_not_exist(self
):
6200 numa
= {"memory": 2}
6202 extra_specs
= {"vmware:latency_sensitivity_level": "high"}
6203 expected_extra_spec
= {"vmware:latency_sensitivity_level": "high"}
6204 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6205 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6207 def test_process_numa_vcpu_empty_node_id(self
):
6208 numa
= {"vcpu": [2]}
6211 expected_extra_spec
= {"hw:numa_cpus.": "2"}
6212 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6213 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6215 def test_process_numa_vcpu_empty_numa_dict(self
):
6219 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6220 self
.assertDictEqual(extra_specs
, {})
6222 def test_process_numa_vcpu_str_node_id(self
):
6223 numa
= {"vcpu": [2]}
6226 expected_extra_spec
= {"hw:numa_cpus.12": "2"}
6227 self
.vimconn
.process_numa_vcpu(numa
, node_id
, extra_specs
)
6228 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6230 def test_process_numa_paired_threads_empty_extra_spec(self
):
6231 numa
= {"id": 0, "paired-threads": 3}
6233 expected_extra_spec
= {
6234 "hw:cpu_thread_policy": "require",
6235 "hw:cpu_policy": "dedicated",
6237 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6238 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6239 self
.assertEqual(result
, 6)
6241 def test_process_numa_paired_threads_empty_numa(self
):
6244 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6245 self
.assertDictEqual(extra_specs
, {})
6246 self
.assertEqual(result
, None)
6248 def test_process_numa_paired_threads_not_exist(self
):
6249 numa
= {"vcpu": [2]}
6251 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6252 self
.assertDictEqual(extra_specs
, {})
6253 self
.assertEqual(result
, None)
6255 def test_process_numa_paired_threads_str_thread_num(self
):
6256 numa
= {"id": 0, "paired-threads": "3"}
6258 expected_extra_spec
= {
6259 "hw:cpu_thread_policy": "require",
6260 "hw:cpu_policy": "dedicated",
6262 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6263 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6264 self
.assertEqual(result
, "33")
6266 def test_process_numa_paired_threads_none_thread_num(self
):
6267 numa
= {"id": 0, "paired-threads": None}
6269 result
= self
.vimconn
.process_numa_paired_threads(numa
, extra_specs
)
6270 self
.assertDictEqual(extra_specs
, {})
6271 self
.assertEqual(result
, None)
6273 def test_process_numa_cores_empty_extra_spec(self
):
6274 numa
= {"id": 0, "cores": 1}
6276 expected_extra_spec
= {
6277 "hw:cpu_policy": "dedicated",
6278 "hw:cpu_thread_policy": "isolate",
6280 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6281 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6282 self
.assertEqual(result
, 1)
6284 def test_process_numa_cores_not_exist(self
):
6285 numa
= {"id": 0, "paired-threads": 3}
6287 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6288 self
.assertDictEqual(extra_specs
, {})
6289 self
.assertEqual(result
, None)
6291 def test_process_numa_cores_empty_numa(self
):
6293 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
6294 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6295 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6296 self
.assertEqual(result
, None)
6298 def test_process_numa_cores_none_core_num(self
):
6299 numa
= {"memory": 1, "cores": None}
6301 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6302 self
.assertDictEqual(extra_specs
, {})
6303 self
.assertEqual(result
, None)
6305 def test_process_numa_cores_string_core_num(self
):
6306 numa
= {"id": 0, "cores": "1"}
6307 extra_specs
= {"some-key": "some-val"}
6308 expected_extra_spec
= {
6309 "hw:cpu_policy": "dedicated",
6310 "hw:cpu_thread_policy": "isolate",
6311 "some-key": "some-val",
6313 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6314 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6315 self
.assertEqual(result
, "1")
6317 def test_process_numa_cores_float_core_num(self
):
6318 numa
= {"memory": 2, "cores": 10.03}
6319 extra_specs
= {"some-key": "some-val"}
6320 expected_extra_spec
= {
6321 "hw:cpu_policy": "dedicated",
6322 "hw:cpu_thread_policy": "isolate",
6323 "some-key": "some-val",
6325 result
= self
.vimconn
.process_numa_cores(numa
, extra_specs
)
6326 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6327 self
.assertEqual(result
, 10.03)
6329 def test_process_numa_threads_empty_extra_spec_int_thread_num(self
):
6330 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3}
6332 expected_extra_spec
= {
6333 "hw:cpu_policy": "dedicated",
6334 "hw:cpu_thread_policy": "prefer",
6336 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6337 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6338 self
.assertEqual(result
, 3)
6340 def test_process_numa_threads_empty_numa(self
):
6342 extra_specs
= {"some-key": "some-val"}
6343 expected_extra_spec
= {"some-key": "some-val"}
6344 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6345 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6346 self
.assertEqual(result
, None)
6348 def test_process_numa_threads_not_exist(self
):
6349 numa
= {"memory": 1}
6350 extra_specs
= expected_extra_spec
= {"some-key": "some-val"}
6351 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6352 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6353 self
.assertEqual(result
, None)
6355 def test_process_numa_threads_str_thread_num(self
):
6356 numa
= {"vcpu": [1, 3], "threads": "3"}
6358 expected_extra_spec
= {
6359 "hw:cpu_policy": "dedicated",
6360 "hw:cpu_thread_policy": "prefer",
6362 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6363 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6364 self
.assertEqual(result
, "3")
6366 def test_process_numa_threads_none_thread_num(self
):
6367 numa
= {"vcpu": [1, 3], "threads": None}
6369 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6370 self
.assertDictEqual(extra_specs
, {})
6371 self
.assertEqual(result
, None)
6373 def test_process_numa_threads_float_thread_num(self
):
6374 numa
= {"memory": 1, "vcpu": [1, 3], "threads": 3.3}
6375 extra_specs
= {"some-key": "some-val"}
6376 expected_extra_spec
= {
6377 "hw:cpu_policy": "dedicated",
6378 "hw:cpu_thread_policy": "prefer",
6379 "some-key": "some-val",
6381 result
= self
.vimconn
.process_numa_threads(numa
, extra_specs
)
6382 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
6383 self
.assertEqual(result
, 3.3)
6385 def test_change_the_flavor_name_not_existing_name(self
):
6386 """Flavor name does not exist in Openstack flavor list."""
6387 self
.flavor1
.name
= "sample-flavor-3"
6388 self
.flavor2
.name
= "other-flavor-4"
6389 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6390 name
= "other-flavor-3"
6392 flavor_data
= {"name": "other-flavor"}
6393 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6394 self
.assertEqual(result
, name
)
6395 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6396 # Checking whether name_suffix changed or not.
6397 self
.assertEqual(name_suffix
, 3)
6399 def test_change_the_flavor_name_existing_name(self
):
6400 """Flavor name exists in Openstack flavor list."""
6401 self
.flavor1
.name
= "other-flavor-6"
6402 self
.flavor2
.name
= "other-flavor-3"
6403 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6404 name
= "other-flavor-3"
6406 flavor_data
= {"name": "other-flavor"}
6407 expected_result
= "other-flavor-7"
6408 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6409 self
.assertEqual(result
, expected_result
)
6410 # Checking whether name_suffix changed or not.
6411 self
.assertEqual(name_suffix
, 5)
6412 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6414 def test_change_the_flavor_name_flavor_data_does_not_have_name(self
):
6415 """Flavor data does not have name."""
6416 self
.flavor1
.name
= "other-flavor-6"
6417 self
.flavor2
.name
= "other-flavor-3"
6418 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6419 name
= "other-flavor-3"
6422 with self
.assertRaises(KeyError):
6423 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6424 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6425 # Checking whether name_suffix changed or not.
6426 self
.assertEqual(name_suffix
, 5)
6428 def test_change_the_flavor_name_invalid_name_suffix(self
):
6429 """Name suffix is invalid."""
6430 self
.flavor1
.name
= "other-flavor-6"
6431 self
.flavor2
.name
= "other-flavor-3"
6432 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6433 name
= "other-flavor-3"
6435 flavor_data
= {"name": "other-flavor"}
6436 with self
.assertRaises(TypeError):
6437 self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6438 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6439 # Checking whether name_suffix changed or not.
6440 self
.assertEqual(name_suffix
, "a")
6442 def test_change_the_flavor_name_given_name_is_empty(self
):
6443 """Given name is empty string."""
6444 self
.flavor1
.name
= "other-flavor-6"
6445 self
.flavor2
.name
= "other-flavor-3"
6446 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6449 flavor_data
= {"name": "other-flavor"}
6450 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6451 self
.assertEqual(result
, "")
6452 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6453 # Checking whether name_suffix increased or not.
6454 self
.assertEqual(name_suffix
, 3)
6456 def test_change_the_flavor_name_given_name_is_none(self
):
6457 """Given name is None."""
6458 self
.flavor1
.name
= "other-flavor-6"
6459 self
.flavor2
.name
= "other-flavor-3"
6460 self
.vimconn
.nova
.flavors
.list.return_value
= [self
.flavor1
, self
.flavor2
]
6463 flavor_data
= {"name": "other-flavor"}
6464 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6465 self
.assertEqual(result
, None)
6466 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6467 # Checking whether name_suffix increased or not.
6468 self
.assertEqual(name_suffix
, 6)
6470 def test_change_the_flavor_name_empty_nova_flavor_list(self
):
6471 """Nova flavor list is empty."""
6472 self
.vimconn
.nova
.flavors
.list.return_value
= []
6473 name
= "other-flavor-3"
6475 flavor_data
= {"name": "other-flavor"}
6476 result
= self
.vimconn
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
6477 self
.vimconn
.nova
.flavors
.list.assert_called_once()
6478 self
.assertEqual(result
, name
)
6479 # Checking whether name_suffix increased or not.
6480 self
.assertEqual(name_suffix
, 5)
6484 "_process_numa_parameters_of_flavor",
6485 new_callable
=CopyingMock(),
6487 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6488 def test_process_extended_config_of_flavor_with_numa_cpu_mem_vif_disk_quota(
6489 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6491 """Process extended config, extended has numas, cpu, mem, vif and disk-io quota."""
6493 {"memory": 1, "vcpu": [1, 3], "threads": 3},
6494 {"memory": 2, "vcpu": [2]},
6498 "cpu-quota": {"limit": 3},
6499 "mem-quota": {"limit": 1},
6500 "vif-quota": {"limit": 10},
6501 "disk-io-quota": {"limit": 50},
6502 "mempage-size": "LARGE",
6505 expected_extra_specs
= {
6506 "hw:mem_page_size": "large",
6508 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6510 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6511 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6512 self
.assertEqual(extra_specs
, expected_extra_specs
)
6516 "_process_numa_parameters_of_flavor",
6517 new_callable
=CopyingMock(),
6519 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6520 def test_process_extended_config_of_flavor_with_numa_wrong_disk_quota(
6521 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6523 """Process extended config, extended has wrong disk quota key."""
6525 {"memory": 1, "threads": 3},
6526 {"memory": 2, "vcpu": [2]},
6530 "disk-quota": {"limit": 50},
6531 "mempage-size": "PREFER_LARGE",
6534 expected_extra_specs
= {
6535 "hw:mem_page_size": "any",
6537 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6538 mock_process_resource_quota
.assert_not_called()
6539 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6540 self
.assertEqual(extra_specs
, expected_extra_specs
)
6544 "_process_numa_parameters_of_flavor",
6545 new_callable
=CopyingMock(),
6547 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6548 def test_process_extended_config_of_flavor_without_numa_cpu_mem_vif_disk_quota(
6549 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6551 """Process extended config, extended has cpu, mem, vif and disk-io quota but not numas."""
6553 "cpu-quota": {"limit": 3},
6554 "mem-quota": {"limit": 1},
6555 "vif-quota": {"limit": 10},
6556 "disk-io-quota": {"limit": 50},
6557 "mempage-size": "SMALL",
6560 expected_extra_specs
= {
6561 "hw:mem_page_size": "small",
6563 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6564 self
.assertEqual(mock_process_resource_quota
.call_count
, 4)
6565 mock_process_numa_parameters_of_flavor
.assert_not_called()
6566 self
.assertEqual(extra_specs
, expected_extra_specs
)
6570 "_process_numa_parameters_of_flavor",
6571 new_callable
=CopyingMock(),
6573 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6574 def test_process_extended_config_of_flavor_with_numa_with_cpu_pinning_mem_policy(
6575 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6577 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy."""
6580 {"memory": 2, "vcpu": [2]},
6584 "cpu-quota": {"limit": 3},
6585 "mem-quota": {"limit": 1},
6586 "mempage-size": "LARGE",
6587 "cpu-pinning-policy": "DEDICATED",
6588 "mem-policy": "STRICT",
6591 expected_extra_specs
= {
6592 "hw:mem_page_size": "large",
6593 "hw:cpu_policy": "dedicated",
6594 "hw:numa_mempolicy": "strict",
6596 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6597 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6598 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6599 self
.assertEqual(extra_specs
, expected_extra_specs
)
6603 "_process_numa_parameters_of_flavor",
6604 new_callable
=CopyingMock(),
6606 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6607 def test_process_extended_config_of_flavor_without_numa_with_cpu_pinning_mem_policy(
6608 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6610 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy but not numas."""
6612 "cpu-quota": {"limit": 3},
6613 "mem-quota": {"limit": 1},
6614 "mempage-size": "LARGE",
6615 "cpu-pinning-policy": "DEDICATED",
6616 "mem-policy": "STRICT",
6619 expected_extra_specs
= {
6620 "hw:mem_page_size": "large",
6621 "hw:cpu_policy": "dedicated",
6622 "hw:numa_mempolicy": "strict",
6624 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6625 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6626 mock_process_numa_parameters_of_flavor
.assert_not_called()
6627 self
.assertEqual(extra_specs
, expected_extra_specs
)
6631 "_process_numa_parameters_of_flavor",
6632 new_callable
=CopyingMock(),
6634 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6635 def test_process_extended_config_of_flavor_without_numa_with_wrong_mempage_size(
6636 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6638 """Process extended config, extended has wrong mempage-size without numas."""
6640 "cpu-quota": {"limit": 3},
6641 "mem-quota": {"limit": 1},
6642 "mempage-size": "SIZE_2GB",
6643 "cpu-pinning-policy": "DEDICATED",
6644 "mem-policy": "STRICT",
6648 expected_extra_specs
= {
6649 "hw:cpu_policy": "dedicated",
6650 "hw:numa_mempolicy": "strict",
6652 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6653 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6654 mock_process_numa_parameters_of_flavor
.assert_not_called()
6655 self
.assertEqual(extra_specs
, expected_extra_specs
)
6659 "_process_numa_parameters_of_flavor",
6660 new_callable
=CopyingMock(),
6662 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6663 def test_process_extended_config_of_flavor_with_numa_with_wrong_mempage_size(
6664 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6666 """Process extended config, extended has wrong mempage-size with numas."""
6669 {"memory": 2, "vcpu": [2]},
6673 "cpu-quota": {"limit": 3},
6674 "mem-quota": {"limit": 1},
6675 "mempage-size": "SIZE_2GB",
6676 "cpu-pinning-policy": "DEDICATED",
6677 "mem-policy": "STRICT",
6680 expected_extra_specs
= {
6681 "hw:cpu_policy": "dedicated",
6682 "hw:numa_mempolicy": "strict",
6684 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6685 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6686 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
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_none_vcpus(
6696 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6698 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6701 {"memory": 2, "vcpu": [2]},
6705 "cpu-quota": {"limit": 3},
6706 "mem-quota": {"limit": 1},
6707 "mempage-size": "SIZE_2GB",
6708 "cpu-pinning-policy": "DEDICATED",
6709 "mem-policy": "STRICT",
6712 expected_extra_specs
= {
6713 "hw:cpu_policy": "dedicated",
6714 "hw:numa_mempolicy": "strict",
6716 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6717 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6718 mock_process_numa_parameters_of_flavor
.assert_called_once_with(numas
, {})
6719 self
.assertEqual(extra_specs
, expected_extra_specs
)
6723 "_process_numa_parameters_of_flavor",
6724 new_callable
=CopyingMock(),
6726 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6727 def test_process_extended_config_of_flavor_none_vcpus_without_numas(
6728 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6730 """Process extended config, extended has cpu, mem quota, cpu-pinning and mem-policy, vcpus is None."""
6732 "cpu-quota": {"limit": 3},
6733 "mem-quota": {"limit": 1},
6734 "mempage-size": "SIZE_2GB",
6735 "cpu-pinning-policy": "DEDICATED",
6736 "mem-policy": "STRICT",
6738 extra_specs
= {"some-key": "some-val"}
6739 expected_extra_specs
= {
6740 "hw:cpu_policy": "dedicated",
6741 "hw:numa_mempolicy": "strict",
6742 "some-key": "some-val",
6744 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6745 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6746 mock_process_numa_parameters_of_flavor
.assert_not_called()
6747 self
.assertEqual(extra_specs
, expected_extra_specs
)
6751 "_process_numa_parameters_of_flavor",
6752 new_callable
=CopyingMock(),
6754 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6755 def test_process_extended_config_of_flavor_wrong_cpu_pinning_mem_policy_empty_vcpus(
6756 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6758 """Process extended config, extended has wrong cpu-pinning and mem-policy keys."""
6761 {"memory": 2, "vcpu": [2]},
6765 "cpu-quota": {"limit": 3},
6766 "mem-quota": {"limit": 1},
6767 "mempage-size": "SIZE_2GB",
6768 "cpu-pinning-pol": "DEDICATED",
6769 "mem-pol": "STRICT",
6772 expected_extra_specs
= {}
6773 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6774 self
.assertEqual(mock_process_resource_quota
.call_count
, 2)
6775 mock_process_numa_parameters_of_flavor
.assert_called_once_with(
6778 self
.assertEqual(extra_specs
, expected_extra_specs
)
6782 "_process_numa_parameters_of_flavor",
6783 new_callable
=CopyingMock(),
6785 @patch.object(vimconnector
, "process_resource_quota", new_callable
=CopyingMock())
6786 def test_process_extended_config_of_flavor_empty_extended(
6787 self
, mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
6789 """Process extended config, extended is empty."""
6792 self
.vimconn
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
6793 check_if_assert_not_called(
6794 [mock_process_resource_quota
, mock_process_numa_parameters_of_flavor
]
6796 self
.assertEqual(extra_specs
, {})
6798 def test_get_flavor_details_empty_flavor_data(self
):
6800 expected_result
= (64, 1, {}, None)
6801 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6802 self
.assertEqual(result
, expected_result
)
6804 def test_get_flavor_details_flavor_data_has_ram_vcpus_extended(self
):
6809 "some-key": "some-val",
6812 expected_result
= (32, 3, {}, {"some-key": "some-val"})
6813 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6814 self
.assertEqual(result
, expected_result
)
6816 def test_get_flavor_details_flavor_data_is_none(self
):
6818 with self
.assertRaises(AttributeError):
6819 self
.vimconn
._get
_flavor
_details
(flavor_data
)
6821 def test_get_flavor_details_flavor_data_has_only_extended(self
):
6824 "some-key": "some-val",
6827 expected_result
= (64, 1, {}, {"some-key": "some-val"})
6828 result
= self
.vimconn
._get
_flavor
_details
(flavor_data
)
6829 self
.assertEqual(result
, expected_result
)
6831 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6834 "_process_extended_config_of_flavor",
6835 new_callable
=CopyingMock(),
6837 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6838 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6839 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6840 def test_new_flavor_with_extended_with_extra_specs(
6842 mock_format_exception
,
6843 mock_reload_connection
,
6844 mock_change_flavor_name
,
6845 mock_extended_config_of_flavor
,
6846 mock_get_flavor_details
,
6848 """Create new flavor with using extended parameters and extra specs."""
6851 mock_change_flavor_name
.return_value
= name1
6852 mock_get_flavor_details
.return_value
= (
6855 {"some-key": "some-value"},
6858 expected_result
= self
.new_flavor
.id
6859 result
= self
.vimconn
.new_flavor(flavor_data
)
6860 self
.assertEqual(result
, expected_result
)
6861 mock_reload_connection
.assert_called_once()
6862 self
.new_flavor
.set_keys
.assert_called_once()
6863 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6864 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6865 mock_extended_config_of_flavor
.assert_called_once_with(
6866 extended
, {"some-key": "some-value"}
6868 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6869 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6871 mock_format_exception
.assert_not_called()
6873 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6876 "_process_extended_config_of_flavor",
6877 new_callable
=CopyingMock(),
6879 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6880 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6881 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6882 def test_new_flavor_with_extended_without_extra_specs(
6884 mock_format_exception
,
6885 mock_reload_connection
,
6886 mock_change_flavor_name
,
6887 mock_extended_config_of_flavor
,
6888 mock_get_flavor_details
,
6890 """Create new flavor with using extended parameters without extra specs."""
6893 mock_change_flavor_name
.return_value
= name1
6894 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6895 expected_result
= self
.new_flavor
.id
6896 result
= self
.vimconn
.new_flavor(flavor_data
)
6897 self
.assertEqual(result
, expected_result
)
6898 mock_reload_connection
.assert_called_once()
6899 mock_get_flavor_details
.assert_called_once_with(flavor_data
)
6900 mock_change_flavor_name
.assert_called_once_with(name1
, name_suffix
, flavor_data
)
6901 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6902 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6903 name
=name1
, ram
=3, vcpus
=vcpus
, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6905 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
6907 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6910 "_process_extended_config_of_flavor",
6911 new_callable
=CopyingMock(),
6913 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6914 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6915 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6916 def test_new_flavor_change_name_if_used_false_with_extended(
6918 mock_format_exception
,
6919 mock_reload_connection
,
6920 mock_change_flavor_name
,
6921 mock_extended_config_of_flavor
,
6922 mock_get_flavor_details
,
6924 """Create new flavor, change_name_if_used_false, there is extended."""
6926 mock_get_flavor_details
.return_value
= (3, vcpus
, {}, extended
)
6927 expected_result
= self
.new_flavor
.id
6928 result
= self
.vimconn
.new_flavor(flavor_data
, False)
6929 self
.assertEqual(result
, expected_result
)
6930 mock_reload_connection
.assert_called_once()
6931 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6932 mock_extended_config_of_flavor
.assert_called_once_with(extended
, {})
6933 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6934 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6936 check_if_assert_not_called(
6937 [mock_change_flavor_name
, mock_format_exception
, self
.new_flavor
.set_keys
]
6940 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6943 "_process_extended_config_of_flavor",
6944 new_callable
=CopyingMock(),
6946 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6947 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6948 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6949 def test_new_flavor_change_name_if_used_true_without_extended(
6951 mock_format_exception
,
6952 mock_reload_connection
,
6953 mock_change_flavor_name
,
6954 mock_extended_config_of_flavor
,
6955 mock_get_flavor_details
,
6957 """Create new flavor without extended parameters."""
6959 mock_change_flavor_name
.return_value
= name1
6960 expected_result
= self
.new_flavor
.id
6961 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
6962 result
= self
.vimconn
.new_flavor(flavor_data2
)
6963 self
.assertEqual(result
, expected_result
)
6964 mock_reload_connection
.assert_called_once()
6965 mock_change_flavor_name
.assert_called_once_with(
6966 name1
, name_suffix
, flavor_data2
6968 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
6969 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
6970 name
=name1
, ram
=3, vcpus
=8, disk
=50, ephemeral
=0, swap
=0, is_public
=True
6972 check_if_assert_not_called(
6974 self
.new_flavor
.set_keys
,
6975 mock_extended_config_of_flavor
,
6976 mock_format_exception
,
6980 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
6983 "_process_extended_config_of_flavor",
6984 new_callable
=CopyingMock(),
6986 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
6987 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
6988 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
6989 def test_new_flavor_reload_connection_exception(
6991 mock_format_exception
,
6992 mock_reload_connection
,
6993 mock_change_flavor_name
,
6994 mock_extended_config_of_flavor
,
6995 mock_get_flavor_details
,
6997 """Create new flavor, reload connection exception occurred."""
6998 error_msg
= "Can not connect to client APIs."
6999 error
= nvExceptions
.ClientException(error_msg
)
7000 mock_change_flavor_name
.return_value
= name1
7001 mock_reload_connection
.side_effect
= error
7002 with self
.assertRaises(Exception) as err
:
7003 self
.vimconn
.new_flavor(flavor_data2
)
7004 self
.assertEqual(str(err
.exception
), "Can not connect to client APIs.")
7005 self
.assertEqual(mock_reload_connection
.call_count
, 1)
7006 call_mock_format_exception
= mock_format_exception
.call_args
7008 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
7010 check_if_assert_not_called(
7012 mock_change_flavor_name
,
7013 mock_get_flavor_details
,
7014 mock_extended_config_of_flavor
,
7015 self
.vimconn
.nova
.flavors
.create
,
7019 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7022 "_process_extended_config_of_flavor",
7023 new_callable
=CopyingMock(autospec
=True),
7025 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7026 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7027 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7028 def test_new_flavor_flavor_data_without_name(
7030 mock_format_exception
,
7031 mock_reload_connection
,
7032 mock_change_flavor_name
,
7033 mock_extended_config_of_flavor
,
7034 mock_get_flavor_details
,
7036 """Create new flavor, flavor data does not have name."""
7043 self
.vimconn
.new_flavor(flavor_data3
)
7044 mock_format_exception
.assert_called_once()
7045 call_mock_format_exception
= mock_format_exception
.call_args
7047 str(call_mock_format_exception
[0][0]), str(KeyError(error_msg
))
7049 check_if_assert_not_called(
7051 mock_reload_connection
,
7052 mock_change_flavor_name
,
7053 mock_get_flavor_details
,
7054 mock_extended_config_of_flavor
,
7055 self
.vimconn
.nova
.flavors
.create
,
7059 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7062 "_process_extended_config_of_flavor",
7063 new_callable
=CopyingMock(),
7065 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7066 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7067 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7068 def test_new_flavor_change_flavor_name_has_extended_conflict_exception_recovered_in_retry(
7070 mock_format_exception
,
7071 mock_reload_connection
,
7072 mock_change_flavor_name
,
7073 mock_extended_config_of_flavor
,
7074 mock_get_flavor_details
,
7076 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is extended config."""
7078 error_msg
= "Conflict has occurred while creating flavor name."
7079 error2
= nvExceptions
.Conflict(error_msg
)
7080 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
7081 expected_result
= self
.new_flavor
.id
7082 mock_get_flavor_details
.return_value
= (3, 8, {}, extended
)
7083 result
= self
.vimconn
.new_flavor(flavor_data2
)
7084 self
.assertEqual(result
, expected_result
)
7085 self
.assertEqual(mock_reload_connection
.call_count
, 2)
7086 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
7087 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
7088 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
7089 self
.assertEqual(mock_extended_config_of_flavor
.call_count
, 1)
7090 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
7091 name
="sample-flavor-3",
7099 check_if_assert_not_called([self
.new_flavor
.set_keys
, mock_format_exception
])
7101 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7104 "_process_extended_config_of_flavor",
7105 new_callable
=CopyingMock(),
7107 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7108 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7109 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7110 def test_new_flavor_change_flavor_name_without_extended_conflict_exception_recovered_in_retry(
7112 mock_format_exception
,
7113 mock_reload_connection
,
7114 mock_change_flavor_name
,
7115 mock_extended_config_of_flavor
,
7116 mock_get_flavor_details
,
7118 """Create new flavor, nvExceptions.Conflict occurred and recovered, there is not extended config."""
7120 error2
= nvExceptions
.Conflict(
7121 "Conflict has occurred while creating flavor name."
7123 mock_change_flavor_name
.side_effect
= [error2
, "sample-flavor-3"]
7124 expected_result
= self
.new_flavor
.id
7125 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
7126 result
= self
.vimconn
.new_flavor(flavor_data2
)
7127 self
.assertEqual(result
, expected_result
)
7128 self
.assertEqual(mock_reload_connection
.call_count
, 2)
7129 mock_change_flavor_name
.assert_called_with(name1
, name_suffix
, flavor_data2
)
7130 self
.assertEqual(mock_change_flavor_name
.call_count
, 2)
7131 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
7132 self
.vimconn
.nova
.flavors
.create
.assert_called_once_with(
7133 name
="sample-flavor-3",
7141 check_if_assert_not_called(
7143 self
.new_flavor
.set_keys
,
7144 mock_extended_config_of_flavor
,
7145 mock_format_exception
,
7149 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7152 "_process_extended_config_of_flavor",
7153 new_callable
=CopyingMock(),
7155 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7156 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7157 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7158 def test_new_flavor_change_flavor_name_conflict_exception_change_name_if_used_false(
7160 mock_format_exception
,
7161 mock_reload_connection
,
7162 mock_change_flavor_name
,
7163 mock_extended_config_of_flavor
,
7164 mock_get_flavor_details
,
7166 """Create new flavor, nvExceptions.Conflict occurred,
7167 change_name_if_used is false."""
7168 change_name_if_used
= False
7169 error_msg
= "Conflict has occurred while creating flavor name."
7170 error2
= nvExceptions
.Conflict(error_msg
)
7171 mock_get_flavor_details
.return_value
= (4, 8, {}, None)
7172 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
7173 with self
.assertRaises(Exception) as err
:
7174 self
.vimconn
.new_flavor(flavor_data2
, change_name_if_used
)
7175 self
.assertEqual(str(err
.exception
), error_msg
)
7176 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
7177 self
.vimconn
.nova
.flavors
.create
.assert_called_with(
7178 name
="sample-flavor",
7186 self
.assertEqual(mock_get_flavor_details
.call_count
, 3)
7187 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
7188 self
.assertEqual(mock_reload_connection
.call_count
, 3)
7189 check_if_assert_not_called(
7190 [mock_change_flavor_name
, mock_extended_config_of_flavor
]
7192 _call_mock_format_exception
= mock_format_exception
.call_args
7194 str(_call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
7196 self
.assertEqual(mock_format_exception
.call_count
, 3)
7198 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7201 "_process_extended_config_of_flavor",
7202 new_callable
=CopyingMock(),
7204 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7205 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7206 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7207 def test_new_flavor_client_exception_occurred_change_name_if_used_true(
7209 mock_format_exception
,
7210 mock_reload_connection
,
7211 mock_change_flavor_name
,
7212 mock_extended_config_of_flavor
,
7213 mock_get_flavor_details
,
7215 """Create new flavor, nvExceptions.ClientException occurred,
7216 change_name_if_used is true."""
7217 error_msg
= "Connection failed."
7218 error2
= nvExceptions
.ClientException(error_msg
)
7219 mock_change_flavor_name
.side_effect
= [
7224 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
7225 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
7226 with self
.assertRaises(Exception) as err
:
7227 self
.vimconn
.new_flavor(flavor_data2
)
7229 str(err
.exception
), "Conflict has occurred while creating flavor name."
7231 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
7232 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 1)
7233 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
7235 _call_mock_nova_create_flavor
[0][1],
7238 "name": "sample-flavor-3",
7249 self
.assertEqual(mock_reload_connection
.call_count
, 1)
7250 self
.assertEqual(mock_get_flavor_details
.call_count
, 1)
7251 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
7253 _call_mock_change_flavor
[0][0],
7257 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
7260 self
.assertEqual(mock_change_flavor_name
.call_count
, 1)
7261 mock_extended_config_of_flavor
.assert_not_called()
7262 call_mock_format_exception
= mock_format_exception
.call_args
7264 str(call_mock_format_exception
[0][0]), str(ClientException(error_msg
))
7266 self
.assertEqual(mock_format_exception
.call_count
, 1)
7268 @patch.object(vimconnector
, "_get_flavor_details", new_callable
=CopyingMock())
7271 "_process_extended_config_of_flavor",
7272 new_callable
=CopyingMock(),
7274 @patch.object(vimconnector
, "_change_flavor_name", new_callable
=CopyingMock())
7275 @patch.object(vimconnector
, "_reload_connection", new_callable
=CopyingMock())
7276 @patch.object(vimconnector
, "_format_exception", new_callable
=CopyingMock())
7277 def test_new_flavor_change_flavor_name_conflict_exception_occurred_change_name_if_used_true(
7279 mock_format_exception
,
7280 mock_reload_connection
,
7281 mock_change_flavor_name
,
7282 mock_extended_config_of_flavor
,
7283 mock_get_flavor_details
,
7285 """Create new flavor, nvExceptions.Conflict occurred,
7286 change_name_if_used is true."""
7287 error_msg
= "Conflict has occurred while creating flavor name."
7288 error2
= nvExceptions
.Conflict(error_msg
)
7289 mock_change_flavor_name
.side_effect
= [
7294 mock_get_flavor_details
.return_value
= (3, 8, {}, None)
7295 self
.vimconn
.nova
.flavors
.create
.side_effect
= error2
7296 with self
.assertRaises(Exception) as err
:
7297 self
.vimconn
.new_flavor(flavor_data2
)
7298 self
.assertEqual(str(err
.exception
), error_msg
)
7299 self
.assertEqual(type(err
.exception
), nvExceptions
.Conflict
)
7300 self
.assertEqual(self
.vimconn
.nova
.flavors
.create
.call_count
, 3)
7301 _call_mock_nova_create_flavor
= self
.vimconn
.nova
.flavors
.create
.call_args_list
7303 _call_mock_nova_create_flavor
[0][1],
7306 "name": "sample-flavor-3",
7317 _call_mock_nova_create_flavor
[1][1],
7320 "name": "sample-flavor-4",
7331 _call_mock_nova_create_flavor
[2][1],
7334 "name": "sample-flavor-5",
7344 self
.assertEqual(mock_reload_connection
.call_count
, 3)
7345 _call_mock_change_flavor
= mock_change_flavor_name
.call_args_list
7347 _call_mock_change_flavor
[0][0],
7351 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
7355 _call_mock_change_flavor
[1][0],
7359 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
7363 _call_mock_change_flavor
[2][0],
7367 {"name": "sample-flavor", "ram": 3, "vcpus": 8, "disk": 50},
7370 self
.assertEqual(mock_change_flavor_name
.call_count
, 3)
7371 mock_extended_config_of_flavor
.assert_not_called()
7372 call_mock_format_exception
= mock_format_exception
.call_args
7374 str(call_mock_format_exception
[0][0]), str(Conflict(error_msg
))
7376 self
.assertEqual(mock_format_exception
.call_count
, 1)
7378 def test_process_process_vio_numa_nodes_without_numa_with_extra_spec(self
):
7380 extra_specs
= {"hw:numa_nodes": "0"}
7381 expected_extra_spec
= {
7382 "vmware:latency_sensitivity_level": "high",
7383 "hw:numa_nodes": "0",
7385 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7386 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
7388 def test_process_process_vio_numa_nodes_list_type_numa_nodes_empty_extra_spec(self
):
7389 numa_nodes
= [7, 9, 4]
7391 expected_extra_spec
= {
7392 "vmware:latency_sensitivity_level": "high",
7394 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7395 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
7397 def test_process_process_vio_numa_nodes_with_numa_with_extra_spec(self
):
7399 extra_specs
= {"hw:numa_nodes": "5"}
7400 expected_extra_spec
= {
7401 "vmware:latency_sensitivity_level": "high",
7402 "hw:numa_nodes": "5",
7404 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7405 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
7407 def test_process_process_vio_numa_nodes_none_numa_nodes(self
):
7409 extra_specs
= {"hw:numa_nodes": "None"}
7410 expected_extra_spec
= {
7411 "vmware:latency_sensitivity_level": "high",
7412 "hw:numa_nodes": "None",
7414 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7415 self
.assertDictEqual(extra_specs
, expected_extra_spec
)
7417 def test_process_process_vio_numa_nodes_invalid_type_extra_specs(self
):
7420 with self
.assertRaises(TypeError):
7421 self
.vimconn
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
7424 if __name__
== "__main__":