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 osm_ro_plugin
import vimconn
36 from osm_ro_plugin
.vimconn
import (
37 VimConnConnectionException
,
39 VimConnNotFoundException
,
41 from osm_rovim_openstack
.vimconn_openstack
import vimconnector
43 __author__
= "Igor D.C."
44 __date__
= "$23-aug-2017 23:59:59$"
46 # Variables Used in TestNewVmInstance Class
48 description
= "my firewall"
50 image_id
= "408b73-e9cc-5a6a-t270-82cc4811bd4a"
51 flavor_id
= "208b73-e9cc-5a6a-t270-82cc4811bd4a"
52 affinity_group_list
= []
57 {"size": 10, "image_id": image_id
},
60 availability_zone_index
= 0
61 availability_zone_list
= ["nova"]
62 floating_network_vim_id
= "108b73-e9cc-5a6a-t270-82cc4811bd4a"
63 net_id
= "83372685-f67f-49fd-8722-eabb7692fc22"
64 net2_id
= "46472685-f67f-49fd-8722-eabb7692fc22"
65 mac_address
= "00:00:5e:00:53:af"
66 port_id
= "03372685-f67f-49fd-8722-eabb7692fc22"
67 time_return_value
= 156570000
68 port2_id
= "17472685-f67f-49fd-8722-eabb7692fc22"
69 root_vol_id
= "tc408b73-r9cc-5a6a-a270-82cc4811bd4a"
71 volume_id
= "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"
72 volume_id2
= "o4e0e83-b9uu-4akk-a234-89cc4811bd4a"
73 volume_id3
= "44e0e83-t9uu-4akk-a234-p9cc4811bd4a"
74 virtual_mac_id
= "64e0e83-t9uu-4akk-a234-p9cc4811bd4a"
75 created_items_all_true
= {
76 f
"floating_ip:{floating_network_vim_id}": True,
77 f
"volume:{volume_id}": True,
78 f
"port:{port_id}": True,
82 class TestSfcOperations(unittest
.TestCase
):
83 @mock.patch("logging.getLogger", autospec
=True)
84 def setUp(self
, mock_logger
):
85 # Instantiate dummy VIM connector so we can test it
86 # It throws exception because of dummy parameters,
87 # We are disabling the logging of exception not to print them to console.
88 mock_logger
= logging
.getLogger()
89 mock_logger
.disabled
= True
90 self
.vimconn
= vimconnector(
103 create_sfc_port_pair
,
105 ingress_ports
=["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
106 egress_ports
=["230cdf1b-de37-4891-bc07-f9010cf1f967"],
108 # input to VIM connector
112 # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
114 if sfc_encap
is not None:
118 # what OpenStack is assumed to respond (patch OpenStack"s return value)
119 dict_from_neutron
= {
121 "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
124 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
125 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
126 "ingress": ingress_ports
[0] if len(ingress_ports
) else None,
127 "egress": egress_ports
[0] if len(egress_ports
) else None,
128 "service_function_parameters": {"correlation": correlation
},
131 create_sfc_port_pair
.return_value
= dict_from_neutron
133 # what the VIM connector is expected to
134 # send to OpenStack based on the input
138 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
139 "egress": "230cdf1b-de37-4891-bc07-f9010cf1f967",
140 "service_function_parameters": {"correlation": correlation
},
144 # call the VIM connector
145 if sfc_encap
is None:
146 result
= self
.vimconn
.new_sfi(name
, ingress_ports
, egress_ports
)
148 result
= self
.vimconn
.new_sfi(name
, ingress_ports
, egress_ports
, sfc_encap
)
150 # assert that the VIM connector made the expected call to OpenStack
151 create_sfc_port_pair
.assert_called_with(dict_to_neutron
)
152 # assert that the VIM connector had the expected result / return value
153 self
.assertEqual(result
, dict_from_neutron
["port_pair"]["id"])
155 def _test_new_sf(self
, create_sfc_port_pair_group
):
156 # input to VIM connector
159 "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
160 "12ba215e-3987-4892-bd3a-d0fd91eecf98",
161 "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
164 # what OpenStack is assumed to respond (patch OpenStack"s return value)
165 dict_from_neutron
= {
167 "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
170 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
171 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
172 "port_pairs": instances
,
174 "port_pair_group_parameters": {
176 "ppg_n_tuple_mapping": {
177 "ingress_n_tuple": {},
178 "egress_n_tuple": {},
183 create_sfc_port_pair_group
.return_value
= dict_from_neutron
185 # what the VIM connector is expected to
186 # send to OpenStack based on the input
191 "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
192 "12ba215e-3987-4892-bd3a-d0fd91eecf98",
193 "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
198 # call the VIM connector
199 result
= self
.vimconn
.new_sf(name
, instances
)
201 # assert that the VIM connector made the expected call to OpenStack
202 create_sfc_port_pair_group
.assert_called_with(dict_to_neutron
)
203 # assert that the VIM connector had the expected result / return value
204 self
.assertEqual(result
, dict_from_neutron
["port_pair_group"]["id"])
206 def _test_new_sfp(self
, create_sfc_port_chain
, sfc_encap
, spi
):
207 # input to VIM connector
210 "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
211 "00f23389-bdfa-43c2-8b16-5815f2582fa8",
214 "2314daec-c262-414a-86e3-69bb6fa5bc16",
215 "d8bfdb5d-195e-4f34-81aa-6135705317df",
218 # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
224 # what OpenStack is assumed to respond (patch OpenStack"s return value)
225 dict_from_neutron
= {
227 "id": "5bc05721-079b-4b6e-a235-47cac331cbb6",
230 "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
231 "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
232 "chain_id": chain_id
,
233 "flow_classifiers": classifications
,
234 "port_pair_groups": sfs
,
235 "chain_parameters": {"correlation": correlation
},
238 create_sfc_port_chain
.return_value
= dict_from_neutron
240 # what the VIM connector is expected to
241 # send to OpenStack based on the input
245 "flow_classifiers": [
246 "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
247 "00f23389-bdfa-43c2-8b16-5815f2582fa8",
249 "port_pair_groups": [
250 "2314daec-c262-414a-86e3-69bb6fa5bc16",
251 "d8bfdb5d-195e-4f34-81aa-6135705317df",
253 "chain_parameters": {"correlation": correlation
},
257 dict_to_neutron
["port_chain"]["chain_id"] = spi
259 # call the VIM connector
260 if sfc_encap
is None:
261 dict_to_neutron
["port_chain"]["chain_parameters"] = {"correlation": "mpls"}
263 result
= self
.vimconn
.new_sfp(
264 name
, classifications
, sfs
, sfc_encap
=False
267 result
= self
.vimconn
.new_sfp(
268 name
, classifications
, sfs
, sfc_encap
=False, spi
=spi
272 result
= self
.vimconn
.new_sfp(name
, classifications
, sfs
, sfc_encap
)
274 result
= self
.vimconn
.new_sfp(
275 name
, classifications
, sfs
, sfc_encap
, spi
278 # assert that the VIM connector made the expected call to OpenStack
279 create_sfc_port_chain
.assert_called_with(dict_to_neutron
)
280 # assert that the VIM connector had the expected result / return value
281 self
.assertEqual(result
, dict_from_neutron
["port_chain"]["id"])
283 def _test_new_classification(self
, create_sfc_flow_classifier
, ctype
):
284 # input to VIM connector
285 name
= "osm_classification"
288 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
290 "source_ip_prefix": "192.168.2.0/24",
291 "source_port_range_max": 99,
292 "source_port_range_min": 50,
295 # what OpenStack is assumed to respond (patch OpenStack"s return value)
296 dict_from_neutron
= {"flow_classifier": copy
.copy(definition
)}
297 dict_from_neutron
["flow_classifier"][
299 ] = "7735ec2c-fddf-4130-9712-32ed2ab6a372"
300 dict_from_neutron
["flow_classifier"]["name"] = name
301 dict_from_neutron
["flow_classifier"]["description"] = ""
302 dict_from_neutron
["flow_classifier"][
304 ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
305 dict_from_neutron
["flow_classifier"][
307 ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
308 create_sfc_flow_classifier
.return_value
= dict_from_neutron
310 # what the VIM connector is expected to
311 # send to OpenStack based on the input
312 dict_to_neutron
= {"flow_classifier": copy
.copy(definition
)}
313 dict_to_neutron
["flow_classifier"]["name"] = "osm_classification"
315 # call the VIM connector
316 result
= self
.vimconn
.new_classification(name
, ctype
, definition
)
318 # assert that the VIM connector made the expected call to OpenStack
319 create_sfc_flow_classifier
.assert_called_with(dict_to_neutron
)
320 # assert that the VIM connector had the expected result / return value
321 self
.assertEqual(result
, dict_from_neutron
["flow_classifier"]["id"])
323 @mock.patch
.object(Client
, "create_sfc_flow_classifier")
324 def test_new_classification(self
, create_sfc_flow_classifier
):
325 self
._test
_new
_classification
(
326 create_sfc_flow_classifier
, "legacy_flow_classifier"
329 @mock.patch
.object(Client
, "create_sfc_flow_classifier")
330 def test_new_classification_unsupported_type(self
, create_sfc_flow_classifier
):
332 vimconn
.VimConnNotSupportedException
,
333 self
._test
_new
_classification
,
334 create_sfc_flow_classifier
,
338 @mock.patch
.object(Client
, "create_sfc_port_pair")
339 def test_new_sfi_with_sfc_encap(self
, create_sfc_port_pair
):
340 self
._test
_new
_sfi
(create_sfc_port_pair
, True)
342 @mock.patch
.object(Client
, "create_sfc_port_pair")
343 def test_new_sfi_without_sfc_encap(self
, create_sfc_port_pair
):
344 self
._test
_new
_sfi
(create_sfc_port_pair
, False)
346 @mock.patch
.object(Client
, "create_sfc_port_pair")
347 def test_new_sfi_default_sfc_encap(self
, create_sfc_port_pair
):
348 self
._test
_new
_sfi
(create_sfc_port_pair
, None)
350 @mock.patch
.object(Client
, "create_sfc_port_pair")
351 def test_new_sfi_bad_ingress_ports(self
, create_sfc_port_pair
):
353 "5311c75d-d718-4369-bbda-cdcc6da60fcc",
354 "a0273f64-82c9-11e7-b08f-6328e53f0fa7",
357 vimconn
.VimConnNotSupportedException
,
359 create_sfc_port_pair
,
361 ingress_ports
=ingress_ports
,
365 vimconn
.VimConnNotSupportedException
,
367 create_sfc_port_pair
,
369 ingress_ports
=ingress_ports
,
372 @mock.patch
.object(Client
, "create_sfc_port_pair")
373 def test_new_sfi_bad_egress_ports(self
, create_sfc_port_pair
):
375 "230cdf1b-de37-4891-bc07-f9010cf1f967",
376 "b41228fe-82c9-11e7-9b44-17504174320b",
379 vimconn
.VimConnNotSupportedException
,
381 create_sfc_port_pair
,
383 egress_ports
=egress_ports
,
387 vimconn
.VimConnNotSupportedException
,
389 create_sfc_port_pair
,
391 egress_ports
=egress_ports
,
394 @mock.patch
.object(vimconnector
, "get_sfi")
395 @mock.patch
.object(Client
, "create_sfc_port_pair_group")
396 def test_new_sf(self
, create_sfc_port_pair_group
, get_sfi
):
397 get_sfi
.return_value
= {"sfc_encap": True}
398 self
._test
_new
_sf
(create_sfc_port_pair_group
)
400 @mock.patch
.object(vimconnector
, "get_sfi")
401 @mock.patch
.object(Client
, "create_sfc_port_pair_group")
402 def test_new_sf_inconsistent_sfc_encap(self
, create_sfc_port_pair_group
, get_sfi
):
403 get_sfi
.return_value
= {"sfc_encap": "nsh"}
405 vimconn
.VimConnNotSupportedException
,
407 create_sfc_port_pair_group
,
410 @mock.patch
.object(Client
, "create_sfc_port_chain")
411 def test_new_sfp_with_sfc_encap(self
, create_sfc_port_chain
):
412 self
._test
_new
_sfp
(create_sfc_port_chain
, True, None)
414 @mock.patch
.object(Client
, "create_sfc_port_chain")
415 def test_new_sfp_without_sfc_encap(self
, create_sfc_port_chain
):
416 self
._test
_new
_sfp
(create_sfc_port_chain
, None, None)
417 self
._test
_new
_sfp
(create_sfc_port_chain
, None, 25)
419 @mock.patch
.object(Client
, "create_sfc_port_chain")
420 def test_new_sfp_default_sfc_encap(self
, create_sfc_port_chain
):
421 self
._test
_new
_sfp
(create_sfc_port_chain
, None, None)
423 @mock.patch
.object(Client
, "create_sfc_port_chain")
424 def test_new_sfp_with_sfc_encap_spi(self
, create_sfc_port_chain
):
425 self
._test
_new
_sfp
(create_sfc_port_chain
, True, 25)
427 @mock.patch
.object(Client
, "create_sfc_port_chain")
428 def test_new_sfp_default_sfc_encap_spi(self
, create_sfc_port_chain
):
429 self
._test
_new
_sfp
(create_sfc_port_chain
, None, 25)
431 @mock.patch
.object(Client
, "list_sfc_flow_classifiers")
432 def test_get_classification_list(self
, list_sfc_flow_classifiers
):
433 # what OpenStack is assumed to return to the VIM connector
434 list_sfc_flow_classifiers
.return_value
= {
435 "flow_classifiers": [
437 "source_port_range_min": 2000,
438 "destination_ip_prefix": "192.168.3.0/24",
443 "source_port_range_max": 2000,
444 "destination_port_range_min": 3000,
445 "source_ip_prefix": "192.168.2.0/24",
446 "logical_destination_port": None,
447 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
448 "destination_port_range_max": None,
449 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
450 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
451 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
457 # call the VIM connector
458 filter_dict
= {"protocol": "tcp", "ethertype": "IPv4"}
459 result
= self
.vimconn
.get_classification_list(filter_dict
.copy())
461 # assert that VIM connector called OpenStack with the expected filter
462 list_sfc_flow_classifiers
.assert_called_with(**filter_dict
)
463 # assert that the VIM connector successfully
464 # translated and returned the OpenStack result
469 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
472 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
473 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
474 "ctype": "legacy_flow_classifier",
476 "source_port_range_min": 2000,
477 "destination_ip_prefix": "192.168.3.0/24",
481 "source_port_range_max": 2000,
482 "destination_port_range_min": 3000,
483 "source_ip_prefix": "192.168.2.0/24",
484 "logical_destination_port": None,
485 "destination_port_range_max": None,
486 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
492 def _test_get_sfi_list(self
, list_port_pair
, correlation
, sfc_encap
):
493 # what OpenStack is assumed to return to the VIM connector
494 list_port_pair
.return_value
= {
497 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
499 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
500 "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
501 "service_function_parameters": {"correlation": correlation
},
502 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
503 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
509 # call the VIM connector
510 filter_dict
= {"name": "osm_sfi", "description": ""}
511 result
= self
.vimconn
.get_sfi_list(filter_dict
.copy())
513 # assert that VIM connector called OpenStack with the expected filter
514 list_port_pair
.assert_called_with(**filter_dict
)
515 # assert that the VIM connector successfully
516 # translated and returned the OpenStack result
521 "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
523 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
524 "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
525 "sfc_encap": sfc_encap
,
526 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
527 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
533 @mock.patch
.object(Client
, "list_sfc_port_pairs")
534 def test_get_sfi_list_with_sfc_encap(self
, list_sfc_port_pairs
):
535 self
._test
_get
_sfi
_list
(list_sfc_port_pairs
, "nsh", True)
537 @mock.patch
.object(Client
, "list_sfc_port_pairs")
538 def test_get_sfi_list_without_sfc_encap(self
, list_sfc_port_pairs
):
539 self
._test
_get
_sfi
_list
(list_sfc_port_pairs
, None, False)
541 @mock.patch
.object(Client
, "list_sfc_port_pair_groups")
542 def test_get_sf_list(self
, list_sfc_port_pair_groups
):
543 # what OpenStack is assumed to return to the VIM connector
544 list_sfc_port_pair_groups
.return_value
= {
545 "port_pair_groups": [
548 "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
549 "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
552 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
553 "port_pair_group_parameters": {},
554 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
555 "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
561 # call the VIM connector
562 filter_dict
= {"name": "osm_sf", "description": ""}
563 result
= self
.vimconn
.get_sf_list(filter_dict
.copy())
565 # assert that VIM connector called OpenStack with the expected filter
566 list_sfc_port_pair_groups
.assert_called_with(**filter_dict
)
567 # assert that the VIM connector successfully
568 # translated and returned the OpenStack result
574 "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
575 "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
578 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
579 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
580 "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
586 def _test_get_sfp_list(self
, list_sfc_port_chains
, correlation
, sfc_encap
):
587 # what OpenStack is assumed to return to the VIM connector
588 list_sfc_port_chains
.return_value
= {
591 "port_pair_groups": [
592 "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
593 "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
595 "flow_classifiers": [
596 "1333c2f4-82d7-11e7-a5df-9327f33d104e",
597 "1387ab44-82d7-11e7-9bb0-476337183905",
600 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
601 "chain_parameters": {"correlation": correlation
},
603 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
604 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
610 # call the VIM connector
611 filter_dict
= {"name": "osm_sfp", "description": ""}
612 result
= self
.vimconn
.get_sfp_list(filter_dict
.copy())
614 # assert that VIM connector called OpenStack with the expected filter
615 list_sfc_port_chains
.assert_called_with(**filter_dict
)
616 # assert that the VIM connector successfully
617 # translated and returned the OpenStack result
622 "service_functions": [
623 "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
624 "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
627 "1333c2f4-82d7-11e7-a5df-9327f33d104e",
628 "1387ab44-82d7-11e7-9bb0-476337183905",
631 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
632 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
633 "sfc_encap": sfc_encap
,
635 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
641 @mock.patch
.object(Client
, "list_sfc_port_chains")
642 def test_get_sfp_list_with_sfc_encap(self
, list_sfc_port_chains
):
643 self
._test
_get
_sfp
_list
(list_sfc_port_chains
, "nsh", True)
645 @mock.patch
.object(Client
, "list_sfc_port_chains")
646 def test_get_sfp_list_without_sfc_encap(self
, list_sfc_port_chains
):
647 self
._test
_get
_sfp
_list
(list_sfc_port_chains
, None, False)
649 @mock.patch
.object(Client
, "list_sfc_flow_classifiers")
650 def test_get_classification(self
, list_sfc_flow_classifiers
):
651 # what OpenStack is assumed to return to the VIM connector
652 list_sfc_flow_classifiers
.return_value
= {
653 "flow_classifiers": [
655 "source_port_range_min": 2000,
656 "destination_ip_prefix": "192.168.3.0/24",
661 "source_port_range_max": 2000,
662 "destination_port_range_min": 3000,
663 "source_ip_prefix": "192.168.2.0/24",
664 "logical_destination_port": None,
665 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
666 "destination_port_range_max": None,
667 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
668 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
669 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
675 # call the VIM connector
676 result
= self
.vimconn
.get_classification("22198366-d4e8-4d6b-b4d2-637d5d6cbb7d")
678 # assert that VIM connector called OpenStack with the expected filter
679 list_sfc_flow_classifiers
.assert_called_with(
680 id="22198366-d4e8-4d6b-b4d2-637d5d6cbb7d"
682 # assert that VIM connector successfully returned the OpenStack result
686 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
689 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
690 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
691 "ctype": "legacy_flow_classifier",
693 "source_port_range_min": 2000,
694 "destination_ip_prefix": "192.168.3.0/24",
698 "source_port_range_max": 2000,
699 "destination_port_range_min": 3000,
700 "source_ip_prefix": "192.168.2.0/24",
701 "logical_destination_port": None,
702 "destination_port_range_max": None,
703 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
708 @mock.patch
.object(Client
, "list_sfc_flow_classifiers")
709 def test_get_classification_many_results(self
, list_sfc_flow_classifiers
):
710 # what OpenStack is assumed to return to the VIM connector
711 list_sfc_flow_classifiers
.return_value
= {
712 "flow_classifiers": [
714 "source_port_range_min": 2000,
715 "destination_ip_prefix": "192.168.3.0/24",
720 "source_port_range_max": 2000,
721 "destination_port_range_min": 3000,
722 "source_ip_prefix": "192.168.2.0/24",
723 "logical_destination_port": None,
724 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
725 "destination_port_range_max": None,
726 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
727 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
728 "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
732 "source_port_range_min": 1000,
733 "destination_ip_prefix": "192.168.3.0/24",
738 "source_port_range_max": 1000,
739 "destination_port_range_min": 3000,
740 "source_ip_prefix": "192.168.2.0/24",
741 "logical_destination_port": None,
742 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
743 "destination_port_range_max": None,
744 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
745 "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
746 "id": "3196bafc-82dd-11e7-a205-9bf6c14b0721",
752 # call the VIM connector
754 vimconn
.VimConnConflictException
,
755 self
.vimconn
.get_classification
,
756 "3196bafc-82dd-11e7-a205-9bf6c14b0721",
759 # assert the VIM connector called OpenStack with the expected filter
760 list_sfc_flow_classifiers
.assert_called_with(
761 id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
764 @mock.patch
.object(Client
, "list_sfc_flow_classifiers")
765 def test_get_classification_no_results(self
, list_sfc_flow_classifiers
):
766 # what OpenStack is assumed to return to the VIM connector
767 list_sfc_flow_classifiers
.return_value
= {"flow_classifiers": []}
769 # call the VIM connector
771 vimconn
.VimConnNotFoundException
,
772 self
.vimconn
.get_classification
,
773 "3196bafc-82dd-11e7-a205-9bf6c14b0721",
776 # assert the VIM connector called OpenStack with the expected filter
777 list_sfc_flow_classifiers
.assert_called_with(
778 id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
781 @mock.patch
.object(Client
, "list_sfc_port_pairs")
782 def test_get_sfi(self
, list_sfc_port_pairs
):
783 # what OpenStack is assumed to return to the VIM connector
784 list_sfc_port_pairs
.return_value
= {
787 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
789 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
790 "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
791 "service_function_parameters": {"correlation": "nsh"},
792 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
793 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
799 # call the VIM connector
800 result
= self
.vimconn
.get_sfi("c121ebdd-7f2d-4213-b933-3325298a6966")
802 # assert the VIM connector called OpenStack with the expected filter
803 list_sfc_port_pairs
.assert_called_with(
804 id="c121ebdd-7f2d-4213-b933-3325298a6966"
806 # assert the VIM connector successfully returned the OpenStack result
810 "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
811 "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
814 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
815 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
816 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
821 @mock.patch
.object(Client
, "list_sfc_port_pairs")
822 def test_get_sfi_many_results(self
, list_sfc_port_pairs
):
823 # what OpenStack is assumed to return to the VIM connector
824 list_sfc_port_pairs
.return_value
= {
827 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
829 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
830 "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
831 "service_function_parameters": {"correlation": "nsh"},
832 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
833 "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
837 "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
839 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
840 "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
841 "service_function_parameters": {"correlation": "nsh"},
842 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
843 "id": "c0436d92-82db-11e7-8f9c-5fa535f1261f",
849 # call the VIM connector
851 vimconn
.VimConnConflictException
,
852 self
.vimconn
.get_sfi
,
853 "c0436d92-82db-11e7-8f9c-5fa535f1261f",
856 # assert that VIM connector called OpenStack with the expected filter
857 list_sfc_port_pairs
.assert_called_with(
858 id="c0436d92-82db-11e7-8f9c-5fa535f1261f"
861 @mock.patch
.object(Client
, "list_sfc_port_pairs")
862 def test_get_sfi_no_results(self
, list_sfc_port_pairs
):
863 # what OpenStack is assumed to return to the VIM connector
864 list_sfc_port_pairs
.return_value
= {"port_pairs": []}
866 # call the VIM connector
868 vimconn
.VimConnNotFoundException
,
869 self
.vimconn
.get_sfi
,
870 "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
873 # assert that VIM connector called OpenStack with the expected filter
874 list_sfc_port_pairs
.assert_called_with(
875 id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
878 @mock.patch
.object(Client
, "list_sfc_port_pair_groups")
879 def test_get_sf(self
, list_sfc_port_pair_groups
):
880 # what OpenStack is assumed to return to the VIM connector
881 list_sfc_port_pair_groups
.return_value
= {
882 "port_pair_groups": [
884 "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
886 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
887 "port_pair_group_parameters": {},
888 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
889 "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
895 # call the VIM connector
896 result
= self
.vimconn
.get_sf("b22892fc-82d9-11e7-ae85-0fea6a3b3757")
898 # assert that VIM connector called OpenStack with the expected filter
899 list_sfc_port_pair_groups
.assert_called_with(
900 id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
902 # assert that VIM connector successfully returned the OpenStack result
907 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
908 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
909 "sfis": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
910 "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
915 @mock.patch
.object(Client
, "list_sfc_port_pair_groups")
916 def test_get_sf_many_results(self
, list_sfc_port_pair_groups
):
917 # what OpenStack is assumed to return to the VIM connector
918 list_sfc_port_pair_groups
.return_value
= {
919 "port_pair_groups": [
921 "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
923 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
924 "port_pair_group_parameters": {},
925 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
926 "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
930 "port_pairs": ["0d63799c-82d6-11e7-8deb-a746bb3ae9f5"],
932 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
933 "port_pair_group_parameters": {},
934 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
935 "id": "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
941 # call the VIM connector
943 vimconn
.VimConnConflictException
,
945 "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
948 # assert that VIM connector called OpenStack with the expected filter
949 list_sfc_port_pair_groups
.assert_called_with(
950 id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
953 @mock.patch
.object(Client
, "list_sfc_port_pair_groups")
954 def test_get_sf_no_results(self
, list_sfc_port_pair_groups
):
955 # what OpenStack is assumed to return to the VIM connector
956 list_sfc_port_pair_groups
.return_value
= {"port_pair_groups": []}
958 # call the VIM connector
960 vimconn
.VimConnNotFoundException
,
962 "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
965 # assert that VIM connector called OpenStack with the expected filter
966 list_sfc_port_pair_groups
.assert_called_with(
967 id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
970 @mock.patch
.object(Client
, "list_sfc_port_chains")
971 def test_get_sfp(self
, list_sfc_port_chains
):
972 # what OpenStack is assumed to return to the VIM connector
973 list_sfc_port_chains
.return_value
= {
976 "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
977 "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
979 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
980 "chain_parameters": {"correlation": "nsh"},
982 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
983 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
989 # call the VIM connector
990 result
= self
.vimconn
.get_sfp("821bc9be-82d7-11e7-8ce3-23a08a27ab47")
992 # assert that VIM connector called OpenStack with the expected filter
993 list_sfc_port_chains
.assert_called_with(
994 id="821bc9be-82d7-11e7-8ce3-23a08a27ab47"
996 # assert that VIM connector successfully returned the OpenStack result
1000 "service_functions": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1001 "classifications": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1003 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1004 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1007 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
1012 @mock.patch
.object(Client
, "list_sfc_port_chains")
1013 def test_get_sfp_many_results(self
, list_sfc_port_chains
):
1014 # what OpenStack is assumed to return to the VIM connector
1015 list_sfc_port_chains
.return_value
= {
1018 "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1019 "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1021 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1022 "chain_parameters": {"correlation": "nsh"},
1024 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1025 "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
1029 "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
1030 "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
1032 "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1033 "chain_parameters": {"correlation": "nsh"},
1035 "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
1036 "id": "5d002f38-82de-11e7-a770-f303f11ce66a",
1042 # call the VIM connector
1044 vimconn
.VimConnConflictException
,
1045 self
.vimconn
.get_sfp
,
1046 "5d002f38-82de-11e7-a770-f303f11ce66a",
1049 # assert that VIM connector called OpenStack with the expected filter
1050 list_sfc_port_chains
.assert_called_with(
1051 id="5d002f38-82de-11e7-a770-f303f11ce66a"
1054 @mock.patch
.object(Client
, "list_sfc_port_chains")
1055 def test_get_sfp_no_results(self
, list_sfc_port_chains
):
1056 # what OpenStack is assumed to return to the VIM connector
1057 list_sfc_port_chains
.return_value
= {"port_chains": []}
1059 # call the VIM connector
1061 vimconn
.VimConnNotFoundException
,
1062 self
.vimconn
.get_sfp
,
1063 "5d002f38-82de-11e7-a770-f303f11ce66a",
1066 # assert that VIM connector called OpenStack with the expected filter
1067 list_sfc_port_chains
.assert_called_with(
1068 id="5d002f38-82de-11e7-a770-f303f11ce66a"
1071 @mock.patch
.object(Client
, "delete_sfc_flow_classifier")
1072 def test_delete_classification(self
, delete_sfc_flow_classifier
):
1073 result
= self
.vimconn
.delete_classification(
1074 "638f957c-82df-11e7-b7c8-132706021464"
1076 delete_sfc_flow_classifier
.assert_called_with(
1077 "638f957c-82df-11e7-b7c8-132706021464"
1079 self
.assertEqual(result
, "638f957c-82df-11e7-b7c8-132706021464")
1081 @mock.patch
.object(Client
, "delete_sfc_port_pair")
1082 def test_delete_sfi(self
, delete_sfc_port_pair
):
1083 result
= self
.vimconn
.delete_sfi("638f957c-82df-11e7-b7c8-132706021464")
1084 delete_sfc_port_pair
.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
1085 self
.assertEqual(result
, "638f957c-82df-11e7-b7c8-132706021464")
1087 @mock.patch
.object(Client
, "delete_sfc_port_pair_group")
1088 def test_delete_sf(self
, delete_sfc_port_pair_group
):
1089 result
= self
.vimconn
.delete_sf("638f957c-82df-11e7-b7c8-132706021464")
1090 delete_sfc_port_pair_group
.assert_called_with(
1091 "638f957c-82df-11e7-b7c8-132706021464"
1093 self
.assertEqual(result
, "638f957c-82df-11e7-b7c8-132706021464")
1095 @mock.patch
.object(Client
, "delete_sfc_port_chain")
1096 def test_delete_sfp(self
, delete_sfc_port_chain
):
1097 result
= self
.vimconn
.delete_sfp("638f957c-82df-11e7-b7c8-132706021464")
1098 delete_sfc_port_chain
.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
1099 self
.assertEqual(result
, "638f957c-82df-11e7-b7c8-132706021464")
1103 def __init__(self
, s
):
1110 class CopyingMock(MagicMock
):
1111 def __call__(self
, *args
, **kwargs
):
1112 args
= deepcopy(args
)
1113 kwargs
= deepcopy(kwargs
)
1114 return super(CopyingMock
, self
).__call
__(*args
, **kwargs
)
1117 class TestNewVmInstance(unittest
.TestCase
):
1118 @patch("logging.getLogger", autospec
=True)
1119 def setUp(self
, mock_logger
):
1120 # Instantiate dummy VIM connector so we can test it
1121 # It throws exception because of dummy parameters,
1122 # We are disabling the logging of exception not to print them to console.
1123 mock_logger
= logging
.getLogger()
1124 mock_logger
.disabled
= True
1125 self
.vimconn
= vimconnector(
1135 self
.vimconn
.neutron
= CopyingMock()
1136 self
.vimconn
.nova
= CopyingMock()
1137 self
.vimconn
.cinder
= CopyingMock()
1138 self
.server
= MagicMock(object, autospec
=True)
1139 self
.server
.tenant_id
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
1140 self
.server
.id = "908b73-e9cc-5a6a-t270-82cc4811bd4a"
1141 self
.vimconn
.config
["security_groups"] = "default"
1142 self
.vimconn
.config
["keypair"] = "my_keypair"
1143 self
.vimconn
.security_groups_id
= "12345"
1144 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.32"
1145 self
.vimconn
.logger
= CopyingMock()
1147 @patch.object(vimconnector
, "_get_ids_from_name")
1148 def test_prepare_port_dict_security_security_groups_exists_in_config(
1151 """In VIM config security_groups exists, net port_security is True
1152 no_port_security_extension does not exist.
1154 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1155 net
= {"port_security": True}
1157 result_dict
= {"security_groups": "12345"}
1159 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1160 self
.assertDictEqual(result_dict
, port_dict
)
1161 mock_get_ids
.assert_not_called()
1163 @patch.object(vimconnector
, "_get_ids_from_name")
1164 def test_prepare_port_dict_security_security_groups_exists_in_config_no_security_groups_id(
1167 """In VIM config Security_groups exists, net port_security is True, vim security_groups_id does not exist,
1168 no_port_security_extension does not exist.
1170 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1171 self
.vimconn
.security_groups_id
= None
1172 net
= {"port_security": True}
1174 result_dict
= {"security_groups": None}
1176 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1177 self
.assertDictEqual(result_dict
, port_dict
)
1178 mock_get_ids
.assert_called()
1180 @patch.object(vimconnector
, "_get_ids_from_name")
1181 def test_prepare_port_dict_security_security_groups_exists_security_extension_true_in_config(
1184 """In VIM config security_groups exists, net port_security is True, in VIM security_groups_id exists,
1185 no_port_security_extension set to True.
1187 self
.vimconn
.config
= {
1188 "security_groups": "example_security_group",
1189 "no_port_security_extension": True,
1191 net
= {"port_security": True}
1195 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1196 self
.assertDictEqual(result_dict
, port_dict
)
1197 mock_get_ids
.assert_not_called()
1199 @patch.object(vimconnector
, "_get_ids_from_name")
1200 def test_prepare_port_dict_security_no_security_groups_in_config(
1203 """In VIM config security_group does not exist, net port_security True, in VIM security_groups_id exists,
1204 no_port_security_extension does not exist."""
1205 self
.vimconn
.config
= {}
1206 net
= {"port_security": True}
1210 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1211 self
.assertDictEqual(result_dict
, port_dict
)
1212 mock_get_ids
.assert_not_called()
1214 @patch.object(vimconnector
, "_get_ids_from_name")
1215 def test_prepare_port_dict_security_no_security_groups_security_extension_true_in_config(
1218 """Security_group does not exist, net port_security is True, in VIM security_groups_id exists,
1219 no_port_security_extension set to True."""
1220 self
.vimconn
.config
= {"no_port_security_extension": True}
1221 net
= {"port_security": True}
1225 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1226 self
.assertDictEqual(result_dict
, port_dict
)
1227 mock_get_ids
.assert_not_called()
1229 @patch.object(vimconnector
, "_get_ids_from_name")
1230 def test_prepare_port_dict_security_security_groups_exists_net_port_security_false(
1233 """In VIM config security_group exists, net port_security False, security_groups_id exists,
1234 no_port_security_extension does not exist."""
1235 self
.vimconn
.config
= {"security_groups": "example_security_group"}
1236 net
= {"port_security": False}
1240 self
.vimconn
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1241 self
.assertDictEqual(result_dict
, port_dict
)
1242 mock_get_ids
.assert_not_called()
1244 @patch.object(vimconnector
, "_get_ids_from_name")
1245 def test_prepare_port_dict_security_net_port_security_false_port_security_extension_true(
1248 """In VIM config security_group exists, net port_security False, security_groups_id exists,
1249 no_port_security_extension set to True."""
1250 self
.vimconn
.config
= {
1251 "security_groups": "example_security_group",
1252 "no_port_security_extension": True,
1254 net
= {"port_security": False}
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 def test_prepare_port_dict_binding_net_type_virtual(self
):
1263 """net type is virtual."""
1264 net
= {"type": "virtual"}
1267 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1268 self
.assertDictEqual(result_dict
, port_dict
)
1270 def test_prepare_port_dict_binding_net_type_vf(self
):
1271 """net type is VF, vim_type is not VIO."""
1272 net
= {"type": "VF"}
1273 self
.vimconn
.vim_type
= None
1275 result_dict
= {"binding:vnic_type": "direct"}
1276 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1277 self
.assertDictEqual(port_dict
, result_dict
)
1279 def test_prepare_port_dict_binding_net_type_sriov_vim_type_vio(self
):
1280 """net type is SR-IOV, vim_type is VIO."""
1281 net
= {"type": "SR-IOV"}
1282 self
.vimconn
.vim_type
= "VIO"
1285 "binding:vnic_type": "direct",
1286 "port_security_enabled": False,
1287 "provider_security_groups": [],
1288 "security_groups": [],
1290 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1291 self
.assertDictEqual(port_dict
, result_dict
)
1293 def test_prepare_port_dict_binding_net_type_passthrough(self
):
1294 """net type is pci-passthrough."""
1295 net
= {"type": "PCI-PASSTHROUGH"}
1298 "binding:vnic_type": "direct-physical",
1300 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1301 self
.assertDictEqual(port_dict
, result_dict
)
1303 def test_prepare_port_dict_binding_no_net_type(self
):
1304 """net type is missing."""
1307 with self
.assertRaises(VimConnException
) as err
:
1308 self
.vimconn
._prepare
_port
_dict
_binding
(net
, port_dict
)
1309 self
.assertEqual(str(err
.exception
), "Type is missing in the network details.")
1311 def test_set_fixed_ip(self
):
1312 """new_port has fixed ip."""
1316 "fixed_ips": [{"ip_address": "10.1.2.3"}, {"ip_address": "20.1.2.3"}]
1319 result
= {"ip": "10.1.2.3"}
1320 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1321 self
.assertDictEqual(net
, result
)
1323 def test_set_fixed_ip_no_fixed_ip(self
):
1324 """new_port does not have fixed ip."""
1326 new_port
= {"port": {}}
1327 result
= {"ip": None}
1328 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1329 self
.assertDictEqual(net
, result
)
1331 def test_set_fixed_ip_raise_exception(self
):
1332 """new_port does not have port details."""
1335 with self
.assertRaises(Exception) as err
:
1336 self
.vimconn
._set
_fixed
_ip
(new_port
, net
)
1337 self
.assertEqual(type(err
.exception
), KeyError)
1339 def test_prepare_port_dict_mac_ip_addr(self
):
1340 """mac address and ip address exist."""
1342 "mac_address": mac_address
,
1343 "ip_address": "10.0.1.5",
1347 "mac_address": mac_address
,
1348 "fixed_ips": [{"ip_address": "10.0.1.5"}],
1350 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
1351 self
.assertDictEqual(port_dict
, result_dict
)
1353 def test_prepare_port_dict_mac_ip_addr_no_mac_and_ip(self
):
1354 """mac address and ip address does not exist."""
1358 self
.vimconn
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
1359 self
.assertDictEqual(port_dict
, result_dict
)
1361 def test_create_new_port(self
):
1362 """new port has id and mac address."""
1366 "mac_address": mac_address
,
1369 self
.vimconn
.neutron
.create_port
.return_value
= new_port
1370 net
, port_dict
, created_items
= {}, {}, {}
1371 expected_result
= new_port
1373 "mac_adress": mac_address
,
1376 expected_created_items
= {f
"port:{port_id}": True}
1377 result
= self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1378 self
.assertDictEqual(result
, expected_result
)
1379 self
.assertEqual(net
, expected_net
)
1380 self
.assertEqual(created_items
, expected_created_items
)
1381 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1383 def test_create_new_port_without_mac_or_id(self
):
1384 """new port does not have mac address or ID."""
1386 self
.vimconn
.neutron
.create_port
.return_value
= new_port
1387 net
, port_dict
, created_items
= {}, {}, {}
1388 with self
.assertRaises(KeyError):
1389 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1390 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1392 def test_create_new_port_neutron_create_port_raises_exception(self
):
1393 """Neutron create port raises exception."""
1394 self
.vimconn
.neutron
.create_port
.side_effect
= VimConnException(
1395 "New port is not created."
1397 net
, port_dict
, created_items
= {}, {}, {}
1398 with self
.assertRaises(VimConnException
):
1399 self
.vimconn
._create
_new
_port
(port_dict
, created_items
, net
)
1400 self
.vimconn
.neutron
.create_port
.assert_called_once_with({"port": port_dict
})
1402 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1403 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1404 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1405 @patch.object(vimconnector
, "_create_new_port")
1406 @patch.object(vimconnector
, "_set_fixed_ip")
1407 def test_create_port(
1410 mock_create_new_port
,
1411 mock_prepare_port_dict_mac_ip_addr
,
1412 mock_prepare_port_dict_binding
,
1413 mock_prepare_port_dict_security_groups
,
1415 """Net has name, type, net-id."""
1419 "name": "management",
1426 "mac_address": mac_address
,
1427 "name": "management",
1428 "fixed_ips": [{"ip_address": ip_addr1
}],
1431 mock_create_new_port
.return_value
= new_port
1434 "tag": "management",
1437 "network_id": net_id
,
1438 "name": "management",
1439 "admin_state_up": True,
1442 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1443 net
, name
, created_items
1446 self
.assertDictEqual(new_port_result
, new_port
)
1447 self
.assertDictEqual(port_result
, expected_port
)
1449 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1450 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1451 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1452 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1453 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1455 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1456 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1457 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1458 @patch.object(vimconnector
, "_create_new_port")
1459 @patch.object(vimconnector
, "_set_fixed_ip")
1460 def test_create_port_no_port_name(
1463 mock_create_new_port
,
1464 mock_prepare_port_dict_mac_ip_addr
,
1465 mock_prepare_port_dict_binding
,
1466 mock_prepare_port_dict_security_groups
,
1468 """Net has no name."""
1477 "mac_address": mac_address
,
1479 "fixed_ips": [{"ip_address": ip_addr1
}],
1482 mock_create_new_port
.return_value
= new_port
1488 "network_id": net_id
,
1489 "admin_state_up": True,
1493 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1494 net
, name
, created_items
1497 self
.assertDictEqual(new_port_result
, new_port
)
1498 self
.assertDictEqual(port_result
, expected_port
)
1500 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1501 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1502 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1503 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1504 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1506 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1507 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1508 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1509 @patch.object(vimconnector
, "_create_new_port")
1510 @patch.object(vimconnector
, "_set_fixed_ip")
1511 def test_create_port_nova_api_version_smaller_than_232(
1514 mock_create_new_port
,
1515 mock_prepare_port_dict_mac_ip_addr
,
1516 mock_prepare_port_dict_binding
,
1517 mock_prepare_port_dict_security_groups
,
1519 """Nova api version is smaller than 2.32."""
1520 self
.vimconn
.nova
.api_version
.get_string
.return_value
= "2.30"
1529 "mac_address": mac_address
,
1531 "fixed_ips": [{"ip_address": ip_addr1
}],
1534 mock_create_new_port
.return_value
= new_port
1539 "network_id": net_id
,
1540 "admin_state_up": True,
1544 new_port_result
, port_result
= self
.vimconn
._create
_port
(
1545 net
, name
, created_items
1548 self
.assertDictEqual(new_port_result
, new_port
)
1549 self
.assertDictEqual(port_result
, expected_port
)
1551 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1552 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1553 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1554 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1555 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1557 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1558 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1559 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1560 @patch.object(vimconnector
, "_create_new_port")
1561 @patch.object(vimconnector
, "_set_fixed_ip")
1562 def test_create_port_create_new_port_raise_exception(
1565 mock_create_new_port
,
1566 mock_prepare_port_dict_mac_ip_addr
,
1567 mock_prepare_port_dict_binding
,
1568 mock_prepare_port_dict_security_groups
,
1570 """_create_new_port method raises exception."""
1576 mock_create_new_port
.side_effect
= Exception
1578 "network_id": net_id
,
1579 "admin_state_up": True,
1583 with self
.assertRaises(Exception):
1584 self
.vimconn
._create
_port
(net
, name
, created_items
)
1586 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1587 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1588 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1589 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1590 mock_set_fixed_ip
.assert_not_called()
1592 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1593 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1594 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1595 @patch.object(vimconnector
, "_create_new_port")
1596 @patch.object(vimconnector
, "_set_fixed_ip")
1597 def test_create_port_create_sec_groups_raises_exception(
1600 mock_create_new_port
,
1601 mock_prepare_port_dict_mac_ip_addr
,
1602 mock_prepare_port_dict_binding
,
1603 mock_prepare_port_dict_security_groups
,
1605 """_prepare_port_dict_security_groups method raises exception."""
1611 mock_prepare_port_dict_security_groups
.side_effect
= Exception
1613 "network_id": net_id
,
1614 "admin_state_up": True,
1618 with self
.assertRaises(Exception):
1619 self
.vimconn
._create
_port
(net
, name
, created_items
)
1621 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1623 mock_prepare_port_dict_binding
.assert_not_called()
1624 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
1625 mock_create_new_port
.assert_not_called()
1626 mock_set_fixed_ip
.assert_not_called()
1628 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1629 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1630 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1631 @patch.object(vimconnector
, "_create_new_port")
1632 @patch.object(vimconnector
, "_set_fixed_ip")
1633 def test_create_port_create_port_dict_binding_raise_exception(
1636 mock_create_new_port
,
1637 mock_prepare_port_dict_mac_ip_addr
,
1638 mock_prepare_port_dict_binding
,
1639 mock_prepare_port_dict_security_groups
,
1641 """_prepare_port_dict_binding method raises exception."""
1648 mock_prepare_port_dict_binding
.side_effect
= Exception
1650 "network_id": net_id
,
1651 "admin_state_up": True,
1655 with self
.assertRaises(Exception):
1656 self
.vimconn
._create
_port
(net
, name
, created_items
)
1658 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1660 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1662 mock_prepare_port_dict_mac_ip_addr
.assert_not_called()
1663 mock_create_new_port
.assert_not_called()
1664 mock_set_fixed_ip
.assert_not_called()
1666 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1667 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1668 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1669 @patch.object(vimconnector
, "_create_new_port")
1670 @patch.object(vimconnector
, "_set_fixed_ip")
1671 def test_create_port_create_port_mac_ip_addr_raise_exception(
1674 mock_create_new_port
,
1675 mock_prepare_port_dict_mac_ip_addr
,
1676 mock_prepare_port_dict_binding
,
1677 mock_prepare_port_dict_security_groups
,
1679 """prepare_port_dict_mac_ip_addr method raises exception."""
1685 mock_prepare_port_dict_mac_ip_addr
.side_effect
= Exception
1687 "network_id": net_id
,
1688 "admin_state_up": True,
1692 with self
.assertRaises(Exception):
1693 self
.vimconn
._create
_port
(net
, name
, created_items
)
1695 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1696 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1697 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1699 mock_create_new_port
.assert_not_called()
1700 mock_set_fixed_ip
.assert_not_called()
1702 @patch.object(vimconnector
, "_prepare_port_dict_security_groups")
1703 @patch.object(vimconnector
, "_prepare_port_dict_binding")
1704 @patch.object(vimconnector
, "_prepare_port_dict_mac_ip_addr")
1705 @patch.object(vimconnector
, "_create_new_port")
1706 @patch.object(vimconnector
, "_set_fixed_ip")
1707 def test_create_port_create_port_set_fixed_ip_raise_exception(
1710 mock_create_new_port
,
1711 mock_prepare_port_dict_mac_ip_addr
,
1712 mock_prepare_port_dict_binding
,
1713 mock_prepare_port_dict_security_groups
,
1715 """_set_fixed_ip method raises exception."""
1721 mock_set_fixed_ip
.side_effect
= VimConnException(
1722 "Port detail is missing in new_port."
1725 "network_id": net_id
,
1726 "admin_state_up": True,
1732 "mac_address": mac_address
,
1734 "fixed_ips": [{"ip_address": ip_addr1
}],
1737 mock_create_new_port
.return_value
= new_port
1739 with self
.assertRaises(VimConnException
):
1740 self
.vimconn
._create
_port
(net
, name
, created_items
)
1742 mock_prepare_port_dict_security_groups
.assert_called_once_with(net
, port_dict
)
1743 mock_prepare_port_dict_binding
.assert_called_once_with(net
, port_dict
)
1744 mock_prepare_port_dict_mac_ip_addr
.assert_called_once_with(net
, port_dict
)
1745 mock_create_new_port
.assert_called_once_with(port_dict
, created_items
, net
)
1746 mock_set_fixed_ip
.assert_called_once_with(new_port
, net
)
1748 @patch.object(vimconnector
, "_reload_connection")
1749 @patch.object(vimconnector
, "_create_port")
1750 def test_prepare_network_for_vm_instance_no_net_id(
1751 self
, mock_create_port
, mock_reload_connection
1753 """Nets do not have net_id"""
1754 mock_reload_connection
.side_effect
= None
1759 "port_security": False,
1760 "exit_on_floating_ip_error": False,
1761 "port_security_disable_strategy": "full",
1764 "port_security": True,
1765 "exit_on_floating_ip_error": False,
1766 "floating_ip": True,
1770 external_network
, no_secured_ports
= [], []
1771 expected_external_network
, expected_no_secured_ports
= [], []
1772 expected_net_list_vim
= []
1774 self
.vimconn
._prepare
_network
_for
_vminstance
(
1782 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1783 self
.assertEqual(external_network
, expected_external_network
)
1784 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1786 mock_create_port
.assert_not_called()
1788 @patch.object(vimconnector
, "_reload_connection")
1789 @patch.object(vimconnector
, "_create_port")
1790 def test_prepare_network_for_vm_instance_empty_net_list(
1791 self
, mock_create_port
, mock_reload_connection
1793 """Net list is empty."""
1794 mock_reload_connection
.side_effect
= None
1797 external_network
, no_secured_ports
= [], []
1798 expected_external_network
, expected_no_secured_ports
= [], []
1799 expected_net_list_vim
= []
1801 self
.vimconn
._prepare
_network
_for
_vminstance
(
1809 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1810 self
.assertEqual(external_network
, expected_external_network
)
1811 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1813 mock_create_port
.assert_not_called()
1815 @patch.object(vimconnector
, "_reload_connection")
1816 @patch.object(vimconnector
, "_create_port")
1817 def test_prepare_network_for_vm_instance_use_floating_ip_false_mgmt_net(
1818 self
, mock_create_port
, mock_reload_connection
1820 """Nets have net-id, floating_ip False, mgmt network."""
1821 mock_reload_connection
.side_effect
= None
1826 "floating_ip": False,
1831 mock_create_port
.side_effect
= [
1836 "mac_address": mac_address
,
1840 {"port-dict": port2_id
},
1843 external_network
, no_secured_ports
= [], []
1844 expected_external_network
, expected_no_secured_ports
= [], []
1845 expected_net_list_vim
= [{"port-dict": port2_id
}]
1846 self
.vimconn
._prepare
_network
_for
_vminstance
(
1854 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1855 self
.assertEqual(external_network
, expected_external_network
)
1856 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1858 mock_create_port
.assert_called_once_with(
1861 "floating_ip": False,
1868 @patch.object(vimconnector
, "_reload_connection")
1869 def test_prepare_network_for_vm_instance_mgmt_net_net_port_security_and_floating_ip_true(
1870 self
, mock_reload_connection
1872 """Nets have net-id, use_floating_ip False in VIM config, mgmt network, net floating_ip is True."""
1873 self
.vimconn
.config
["use_floating_ip"] = False
1874 mock_create_port
= CopyingMock()
1875 mock_reload_connection
.side_effect
= None
1880 "floating_ip": True,
1885 mock_create_port
.side_effect
= [
1890 "mac_address": mac_address
,
1894 {"port-dict": port2_id
},
1897 external_network
, no_secured_ports
= [], []
1898 expected_external_network
= [
1901 "floating_ip": True,
1903 "exit_on_floating_ip_error": True,
1906 expected_no_secured_ports
= []
1907 expected_net_list_vim
= [{"port-dict": port2_id
}]
1908 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1909 self
.vimconn
._prepare
_network
_for
_vminstance
(
1917 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1918 self
.assertEqual(external_network
, expected_external_network
)
1919 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
1921 mock_create_port
.assert_called_once_with(
1924 "floating_ip": True,
1931 @patch.object(vimconnector
, "_reload_connection")
1932 def test_prepare_network_for_vm_instance_use_floating_ip_true_mgmt_net_port_security_false(
1933 self
, mock_reload_connection
1935 """Nets have net-id, use_floating_ip is True in VIM config, mgmt network, net port security is False."""
1936 mock_create_port
= CopyingMock()
1937 self
.vimconn
.config
["use_floating_ip"] = True
1938 self
.vimconn
.config
["no_port_security_extension"] = False
1939 mock_reload_connection
.side_effect
= None
1946 "port_security": False,
1947 "exit_on_floating_ip_error": False,
1948 "port_security_disable_strategy": "full",
1952 mock_create_port
.side_effect
= [
1957 "mac_address": mac_address
,
1961 {"port-dict": port2_id
},
1964 external_network
, no_secured_ports
= [], []
1965 expected_external_network
= [
1969 "port_security": False,
1970 "exit_on_floating_ip_error": False,
1971 "port_security_disable_strategy": "full",
1972 "floating_ip": True,
1975 expected_no_secured_ports
= [(port2_id
, "full")]
1976 expected_net_list_vim
= [{"port-dict": port2_id
}]
1977 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
1978 self
.vimconn
._prepare
_network
_for
_vminstance
(
1987 mock_create_port
.assert_called_once_with(
1991 "port_security": False,
1992 "exit_on_floating_ip_error": False,
1993 "port_security_disable_strategy": "full",
1998 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
1999 self
.assertEqual(external_network
, expected_external_network
)
2000 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2002 @patch.object(vimconnector
, "_reload_connection")
2003 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_false(
2004 self
, mock_reload_connection
2006 """Nets have net-id, use_floating_ip True in VIM config, non-mgmt network, port security is False."""
2007 mock_create_port
= CopyingMock()
2008 self
.vimconn
.config
["use_floating_ip"] = True
2009 self
.vimconn
.config
["no_port_security_extension"] = False
2010 mock_reload_connection
.side_effect
= None
2017 "port_security": False,
2018 "port_security_disable_strategy": "full",
2022 mock_create_port
.side_effect
= [
2027 "mac_address": mac_address
,
2031 {"port-dict": port2_id
},
2034 external_network
, no_secured_ports
= [], []
2035 expected_external_network
= []
2036 expected_no_secured_ports
= [(port2_id
, "full")]
2037 expected_net_list_vim
= [{"port-dict": port2_id
}]
2038 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2039 self
.vimconn
._prepare
_network
_for
_vminstance
(
2048 mock_create_port
.assert_called_once_with(
2052 "port_security": False,
2053 "port_security_disable_strategy": "full",
2058 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2059 self
.assertEqual(external_network
, expected_external_network
)
2060 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2062 @patch.object(vimconnector
, "_reload_connection")
2063 def test_prepare_network_for_vm_instance_use_fip_true_non_mgmt_net_port_security_true(
2064 self
, mock_reload_connection
2066 """Nets have net-id, use_floating_ip is True in VIM config, non-mgmt network, net port security is True."""
2067 mock_create_port
= CopyingMock()
2068 self
.vimconn
.config
["use_floating_ip"] = True
2069 self
.vimconn
.config
["no_port_security_extension"] = True
2070 mock_reload_connection
.side_effect
= None
2077 "port_security": True,
2078 "port_security_disable_strategy": "full",
2082 mock_create_port
.side_effect
= [
2087 "mac_address": mac_address
,
2091 {"port-dict": port2_id
},
2094 external_network
, no_secured_ports
= [], []
2095 expected_external_network
= []
2096 expected_no_secured_ports
= []
2097 expected_net_list_vim
= [{"port-dict": port2_id
}]
2098 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2099 self
.vimconn
._prepare
_network
_for
_vminstance
(
2108 mock_create_port
.assert_called_once_with(
2112 "port_security": True,
2113 "port_security_disable_strategy": "full",
2118 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2119 self
.assertEqual(external_network
, expected_external_network
)
2120 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2122 @patch.object(vimconnector
, "_reload_connection")
2123 def test_prepare_network_for_vm_instance_create_port_raise_exception(
2124 self
, mock_reload_connection
2126 """_create_port method raise exception."""
2127 mock_create_port
= CopyingMock()
2128 self
.vimconn
.config
["use_floating_ip"] = True
2129 self
.vimconn
.config
["no_port_security_extension"] = True
2130 mock_reload_connection
.side_effect
= None
2137 "port_security": True,
2138 "port_security_disable_strategy": "full",
2142 mock_create_port
.side_effect
= KeyError
2143 external_network
, no_secured_ports
= [], []
2144 expected_external_network
= []
2145 expected_no_secured_ports
= []
2146 expected_net_list_vim
= []
2147 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2148 with self
.assertRaises(Exception) as err
:
2149 self
.vimconn
._prepare
_network
_for
_vminstance
(
2158 self
.assertEqual(type(err
.exception
), KeyError)
2160 mock_create_port
.assert_called_once_with(
2164 "port_security": True,
2165 "port_security_disable_strategy": "full",
2170 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2171 self
.assertEqual(external_network
, expected_external_network
)
2172 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2174 @patch.object(vimconnector
, "_reload_connection")
2175 def test_prepare_network_for_vm_instance_reload_connection_raise_exception(
2176 self
, mock_reload_connection
2178 """_reload_connection method raises exception."""
2179 mock_create_port
= CopyingMock()
2180 mock_reload_connection
.side_effect
= VimConnConnectionException(
2181 "Connection failed."
2183 self
.vimconn
.config
["use_floating_ip"] = True
2184 self
.vimconn
.config
["no_port_security_extension"] = True
2191 "port_security": True,
2192 "port_security_disable_strategy": "full",
2196 mock_create_port
.side_effect
= None
2197 external_network
, no_secured_ports
= [], []
2198 expected_external_network
= []
2199 expected_no_secured_ports
= []
2200 expected_net_list_vim
= []
2201 with patch
.object(vimconnector
, "_create_port", mock_create_port
):
2202 with self
.assertRaises(Exception) as err
:
2203 self
.vimconn
._prepare
_network
_for
_vminstance
(
2212 self
.assertEqual(type(err
.exception
), VimConnConnectionException
)
2213 self
.assertEqual(str(err
.exception
), "Connection failed.")
2214 mock_reload_connection
.assert_called_once()
2215 mock_create_port
.assert_not_called()
2216 self
.assertEqual(expected_net_list_vim
, net_list_vim
)
2217 self
.assertEqual(external_network
, expected_external_network
)
2218 self
.assertEqual(expected_no_secured_ports
, no_secured_ports
)
2220 def test_prepare_persistent_root_volumes_vim_using_volume_id(self
):
2221 """Existing persistent root volume with vim_volume_id."""
2222 vm_av_zone
= ["nova"]
2223 base_disk_index
= ord("a")
2224 disk
= {"vim_volume_id": volume_id
}
2225 block_device_mapping
= {}
2226 existing_vim_volumes
= []
2228 expected_boot_vol_id
= None
2229 expected_block_device_mapping
= {"vda": volume_id
}
2230 expected_existing_vim_volumes
= [{"id": volume_id
}]
2231 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2236 block_device_mapping
,
2237 existing_vim_volumes
,
2240 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2241 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2242 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2243 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2245 @patch.object(vimconnector
, "update_block_device_mapping")
2246 def test_prepare_persistent_non_root_volumes_vim_using_volume_id(
2247 self
, mock_update_block_device_mapping
2249 """Existing persistent non root volume with vim_volume_id."""
2250 vm_av_zone
= ["nova"]
2251 base_disk_index
= ord("b")
2252 disk
= {"vim_volume_id": volume_id
}
2253 block_device_mapping
= {}
2254 existing_vim_volumes
= []
2256 expected_block_device_mapping
= {"vdb": volume_id
}
2257 expected_existing_vim_volumes
= [{"id": volume_id
}]
2258 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2262 block_device_mapping
,
2264 existing_vim_volumes
,
2267 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2268 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2269 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2270 mock_update_block_device_mapping
.assert_not_called()
2272 @patch.object(vimconnector
, "update_block_device_mapping")
2273 def test_prepare_persistent_root_volumes_using_vim_id(
2274 self
, mock_update_block_device_mapping
2276 """Existing persistent root volume with vim_id."""
2277 vm_av_zone
= ["nova"]
2278 base_disk_index
= ord("a")
2279 disk
= {"vim_id": volume_id
}
2280 block_device_mapping
= {}
2281 existing_vim_volumes
= []
2283 expected_boot_vol_id
= None
2284 expected_block_device_mapping
= {"vda": volume_id
}
2285 expected_existing_vim_volumes
= [{"id": volume_id
}]
2286 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2291 block_device_mapping
,
2292 existing_vim_volumes
,
2295 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2296 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2297 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2298 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2299 mock_update_block_device_mapping
.assert_not_called()
2301 @patch.object(vimconnector
, "update_block_device_mapping")
2302 def test_prepare_persistent_non_root_volumes_using_vim_id(
2303 self
, mock_update_block_device_mapping
2305 """Existing persistent root volume with vim_id."""
2306 vm_av_zone
= ["nova"]
2307 base_disk_index
= ord("b")
2308 disk
= {"vim_id": volume_id
}
2309 block_device_mapping
= {}
2310 existing_vim_volumes
= []
2313 expected_block_device_mapping
= {"vdb": volume_id
}
2314 expected_existing_vim_volumes
= [{"id": volume_id
}]
2315 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2319 block_device_mapping
,
2321 existing_vim_volumes
,
2325 self
.assertDictEqual(block_device_mapping
, expected_block_device_mapping
)
2326 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2327 self
.vimconn
.cinder
.volumes
.create
.assert_not_called()
2328 mock_update_block_device_mapping
.assert_not_called()
2330 @patch.object(vimconnector
, "update_block_device_mapping")
2331 def test_prepare_persistent_root_volumes_create(
2332 self
, mock_update_block_device_mapping
2334 """Create persistent root volume."""
2335 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
2336 vm_av_zone
= ["nova"]
2337 base_disk_index
= ord("a")
2338 disk
= {"size": 10, "image_id": image_id
}
2339 block_device_mapping
= {}
2340 existing_vim_volumes
= []
2342 expected_boot_vol_id
= volume_id2
2343 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2348 block_device_mapping
,
2349 existing_vim_volumes
,
2352 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2353 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2357 availability_zone
=["nova"],
2359 mock_update_block_device_mapping
.assert_called_once()
2360 _call_mock_update_block_device_mapping
= (
2361 mock_update_block_device_mapping
.call_args_list
2364 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
2365 block_device_mapping
,
2368 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
2370 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
2372 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
2375 @patch.object(vimconnector
, "update_block_device_mapping")
2376 def test_prepare_persistent_root_volumes_create_with_keep(
2377 self
, mock_update_block_device_mapping
2379 """Create persistent root volume, disk has keep parameter."""
2380 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
2381 vm_av_zone
= ["nova"]
2382 base_disk_index
= ord("a")
2383 disk
= {"size": 10, "image_id": image_id
, "keep": True}
2384 block_device_mapping
= {}
2385 existing_vim_volumes
= []
2387 expected_boot_vol_id
= volume_id2
2388 expected_existing_vim_volumes
= []
2389 boot_volume_id
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2394 block_device_mapping
,
2395 existing_vim_volumes
,
2398 self
.assertEqual(boot_volume_id
, expected_boot_vol_id
)
2399 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2400 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2404 availability_zone
=["nova"],
2406 mock_update_block_device_mapping
.assert_called_once()
2407 _call_mock_update_block_device_mapping
= (
2408 mock_update_block_device_mapping
.call_args_list
2411 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
2412 block_device_mapping
,
2415 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
2417 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
2419 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
2422 @patch.object(vimconnector
, "update_block_device_mapping")
2423 def test_prepare_persistent_non_root_volumes_create(
2424 self
, mock_update_block_device_mapping
2426 """Create persistent non-root volume."""
2427 self
.vimconn
.cinder
= CopyingMock()
2428 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
2429 vm_av_zone
= ["nova"]
2430 base_disk_index
= ord("a")
2432 block_device_mapping
= {}
2433 existing_vim_volumes
= []
2435 expected_existing_vim_volumes
= []
2436 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2440 block_device_mapping
,
2442 existing_vim_volumes
,
2446 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2447 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2448 size
=10, name
="basicvmvda", availability_zone
=["nova"]
2450 mock_update_block_device_mapping
.assert_called_once()
2451 _call_mock_update_block_device_mapping
= (
2452 mock_update_block_device_mapping
.call_args_list
2455 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
2456 block_device_mapping
,
2459 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
2461 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
2463 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
2466 @patch.object(vimconnector
, "update_block_device_mapping")
2467 def test_prepare_persistent_non_root_volumes_create_with_keep(
2468 self
, mock_update_block_device_mapping
2470 """Create persistent non-root volume."""
2471 self
.vimconn
.cinder
= CopyingMock()
2472 self
.vimconn
.cinder
.volumes
.create
.return_value
.id = volume_id2
2473 vm_av_zone
= ["nova"]
2474 base_disk_index
= ord("a")
2475 disk
= {"size": 10, "keep": True}
2476 block_device_mapping
= {}
2477 existing_vim_volumes
= []
2479 expected_existing_vim_volumes
= []
2480 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2484 block_device_mapping
,
2486 existing_vim_volumes
,
2490 self
.assertEqual(existing_vim_volumes
, expected_existing_vim_volumes
)
2491 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2492 size
=10, name
="basicvmvda", availability_zone
=["nova"]
2494 mock_update_block_device_mapping
.assert_called_once()
2495 _call_mock_update_block_device_mapping
= (
2496 mock_update_block_device_mapping
.call_args_list
2499 _call_mock_update_block_device_mapping
[0].kwargs
["block_device_mapping"],
2500 block_device_mapping
,
2503 _call_mock_update_block_device_mapping
[0].kwargs
["base_disk_index"], 97
2505 self
.assertEqual(_call_mock_update_block_device_mapping
[0].kwargs
["disk"], disk
)
2507 _call_mock_update_block_device_mapping
[0].kwargs
["created_items"], {}
2510 @patch.object(vimconnector
, "update_block_device_mapping")
2511 def test_prepare_persistent_root_volumes_create_raise_exception(
2512 self
, mock_update_block_device_mapping
2514 """Create persistent root volume raise exception."""
2515 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
2516 vm_av_zone
= ["nova"]
2517 base_disk_index
= ord("a")
2518 disk
= {"size": 10, "image_id": image_id
}
2519 block_device_mapping
= {}
2520 existing_vim_volumes
= []
2523 with self
.assertRaises(Exception):
2524 result
= self
.vimconn
._prepare
_persistent
_root
_volumes
(
2529 block_device_mapping
,
2530 existing_vim_volumes
,
2534 self
.assertEqual(result
, None)
2536 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2540 availability_zone
=["nova"],
2542 self
.assertEqual(existing_vim_volumes
, [])
2543 self
.assertEqual(block_device_mapping
, {})
2544 self
.assertEqual(created_items
, {})
2545 mock_update_block_device_mapping
.assert_not_called()
2547 @patch.object(vimconnector
, "update_block_device_mapping")
2548 def test_prepare_persistent_non_root_volumes_create_raise_exception(
2549 self
, mock_update_block_device_mapping
2551 """Create persistent non-root volume raise exception."""
2552 self
.vimconn
.cinder
.volumes
.create
.side_effect
= Exception
2553 vm_av_zone
= ["nova"]
2554 base_disk_index
= ord("b")
2556 block_device_mapping
= {}
2557 existing_vim_volumes
= []
2560 with self
.assertRaises(Exception):
2561 self
.vimconn
._prepare
_non
_root
_persistent
_volumes
(
2565 block_device_mapping
,
2567 existing_vim_volumes
,
2571 self
.vimconn
.cinder
.volumes
.create
.assert_called_once_with(
2572 size
=10, name
="basicvmvdb", availability_zone
=["nova"]
2574 self
.assertEqual(existing_vim_volumes
, [])
2575 self
.assertEqual(block_device_mapping
, {})
2576 self
.assertEqual(created_items
, {})
2577 mock_update_block_device_mapping
.assert_not_called()
2579 @patch("time.sleep")
2580 def test_wait_for_created_volumes_availability_volume_status_available(
2583 """Created volume status is available."""
2585 created_items
= {f
"volume:{volume_id2}": True}
2586 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
2588 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2589 elapsed_time
, created_items
2591 self
.assertEqual(result
, elapsed_time
)
2592 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2593 mock_sleep
.assert_not_called()
2595 @patch("time.sleep")
2596 def test_wait_for_existing_volumes_availability_volume_status_available(
2599 """Existing volume status is available."""
2601 existing_vim_volumes
= [{"id": volume_id2
}]
2602 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
2604 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2605 elapsed_time
, existing_vim_volumes
2607 self
.assertEqual(result
, elapsed_time
)
2608 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2609 mock_sleep
.assert_not_called()
2611 @patch("time.sleep")
2612 def test_wait_for_created_volumes_availability_status_processing_multiple_volumes(
2615 """Created volume status is processing."""
2618 f
"volume:{volume_id2}": True,
2619 f
"volume:{volume_id3}": True,
2621 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2622 Status("processing"),
2623 Status("available"),
2624 Status("available"),
2627 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2628 elapsed_time
, created_items
2630 self
.assertEqual(result
, 10)
2631 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
2632 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
2633 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
2634 self
.assertEqual(_call_mock_get_volumes
[2][0], (volume_id3
,))
2635 mock_sleep
.assert_called_with(5)
2636 self
.assertEqual(1, mock_sleep
.call_count
)
2638 @patch("time.sleep")
2639 def test_wait_for_existing_volumes_availability_status_processing_multiple_volumes(
2642 """Existing volume status is processing."""
2644 existing_vim_volumes
= [
2646 {"id": "44e0e83-b9uu-4akk-t234-p9cc4811bd4a"},
2648 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2649 Status("processing"),
2650 Status("available"),
2651 Status("available"),
2654 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2655 elapsed_time
, existing_vim_volumes
2657 self
.assertEqual(result
, 10)
2658 _call_mock_get_volumes
= self
.vimconn
.cinder
.volumes
.get
.call_args_list
2659 self
.assertEqual(_call_mock_get_volumes
[0][0], (volume_id2
,))
2660 self
.assertEqual(_call_mock_get_volumes
[1][0], (volume_id2
,))
2662 _call_mock_get_volumes
[2][0], ("44e0e83-b9uu-4akk-t234-p9cc4811bd4a",)
2664 mock_sleep
.assert_called_with(5)
2665 self
.assertEqual(1, mock_sleep
.call_count
)
2667 @patch("time.sleep")
2668 def test_wait_for_created_volumes_availability_volume_status_processing_timeout(
2671 """Created volume status is processing, elapsed time greater than timeout (1800)."""
2673 created_items
= {f
"volume:{volume_id2}": True}
2674 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2675 Status("processing"),
2676 Status("processing"),
2678 with
patch("time.sleep", mock_sleep
):
2679 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2680 elapsed_time
, created_items
2682 self
.assertEqual(result
, 1805)
2683 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2684 mock_sleep
.assert_not_called()
2686 @patch("time.sleep")
2687 def test_wait_for_existing_volumes_availability_volume_status_processing_timeout(
2690 """Exsiting volume status is processing, elapsed time greater than timeout (1800)."""
2692 existing_vim_volumes
= [{"id": volume_id2
}]
2693 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [
2694 Status("processing"),
2695 Status("processing"),
2698 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2699 elapsed_time
, existing_vim_volumes
2701 self
.assertEqual(result
, 1805)
2702 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2703 mock_sleep
.assert_not_called()
2705 @patch("time.sleep")
2706 def test_wait_for_created_volumes_availability_cinder_raise_exception(
2709 """Cinder get volumes raises exception for created volumes."""
2711 created_items
= {f
"volume:{volume_id2}": True}
2712 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
2713 with self
.assertRaises(Exception):
2714 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2715 elapsed_time
, created_items
2717 self
.assertEqual(result
, 1000)
2718 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2719 mock_sleep
.assert_not_called()
2721 @patch("time.sleep")
2722 def test_wait_for_existing_volumes_availability_cinder_raise_exception(
2725 """Cinder get volumes raises exception for existing volumes."""
2727 existing_vim_volumes
= [{"id": volume_id2
}]
2728 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception
2729 with self
.assertRaises(Exception):
2730 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2731 elapsed_time
, existing_vim_volumes
2733 self
.assertEqual(result
, 1000)
2734 self
.vimconn
.cinder
.volumes
.get
.assert_called_with(volume_id2
)
2735 mock_sleep
.assert_not_called()
2737 @patch("time.sleep")
2738 def test_wait_for_created_volumes_availability_no_volume_in_created_items(
2741 """Created_items dict does not have volume-id."""
2745 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
2747 result
= self
.vimconn
._wait
_for
_created
_volumes
_availability
(
2748 elapsed_time
, created_items
2750 self
.assertEqual(result
, 10)
2751 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2752 mock_sleep
.assert_not_called()
2754 @patch("time.sleep")
2755 def test_wait_for_existing_volumes_availability_no_volume_in_existing_vim_volumes(
2758 """Existing_vim_volumes list does not have volume."""
2760 existing_vim_volumes
= []
2762 self
.vimconn
.cinder
.volumes
.get
.side_effect
= [None]
2764 result
= self
.vimconn
._wait
_for
_existing
_volumes
_availability
(
2765 elapsed_time
, existing_vim_volumes
2767 self
.assertEqual(result
, 10)
2768 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
2769 mock_sleep
.assert_not_called()
2771 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2772 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2773 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2774 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2775 def test_prepare_disk_for_vm_instance(
2777 mock_existing_vol_availability
,
2778 mock_created_vol_availability
,
2779 mock_non_root_volumes
,
2782 """Prepare disks for VM instance successfully."""
2783 existing_vim_volumes
= []
2785 block_device_mapping
= {}
2786 vm_av_zone
= ["nova"]
2788 mock_root_volumes
.return_value
= root_vol_id
2789 mock_created_vol_availability
.return_value
= 10
2790 mock_existing_vol_availability
.return_value
= 15
2791 self
.vimconn
.cinder
= CopyingMock()
2792 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2794 existing_vim_volumes
,
2797 block_device_mapping
,
2800 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_called_once_with(
2803 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2804 mock_existing_vol_availability
.assert_called_once_with(10, existing_vim_volumes
)
2805 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2806 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2807 mock_root_volumes
.assert_called_once_with(
2809 vm_av_zone
=["nova"],
2810 disk
={"size": 10, "image_id": image_id
},
2812 block_device_mapping
={},
2813 existing_vim_volumes
=[],
2816 mock_non_root_volumes
.assert_called_once_with(
2819 vm_av_zone
=["nova"],
2821 block_device_mapping
={},
2822 existing_vim_volumes
=[],
2826 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2827 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2828 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2829 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2830 def test_prepare_disk_for_vm_instance_timeout_exceeded(
2832 mock_existing_vol_availability
,
2833 mock_created_vol_availability
,
2834 mock_non_root_volumes
,
2837 """Timeout exceeded while waiting for disks."""
2838 existing_vim_volumes
= []
2840 vm_av_zone
= ["nova"]
2841 block_device_mapping
= {}
2843 mock_root_volumes
.return_value
= root_vol_id
2844 mock_created_vol_availability
.return_value
= 1700
2845 mock_existing_vol_availability
.return_value
= 1900
2847 with self
.assertRaises(VimConnException
) as err
:
2848 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2850 existing_vim_volumes
,
2853 block_device_mapping
,
2857 str(err
.exception
), "Timeout creating volumes for instance basicvm"
2859 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2860 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2861 mock_existing_vol_availability
.assert_called_once_with(
2862 1700, existing_vim_volumes
2864 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2865 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2866 mock_root_volumes
.assert_called_once_with(
2868 vm_av_zone
=["nova"],
2869 disk
={"size": 10, "image_id": image_id
},
2871 block_device_mapping
={},
2872 existing_vim_volumes
=[],
2875 mock_non_root_volumes
.assert_called_once_with(
2878 vm_av_zone
=["nova"],
2880 block_device_mapping
={},
2881 existing_vim_volumes
=[],
2885 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2886 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2887 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2888 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2889 def test_prepare_disk_for_vm_instance_empty_disk_list(
2891 mock_existing_vol_availability
,
2892 mock_created_vol_availability
,
2893 mock_non_root_volumes
,
2896 """Disk list is empty."""
2897 existing_vim_volumes
= []
2899 block_device_mapping
= {}
2900 vm_av_zone
= ["nova"]
2901 mock_created_vol_availability
.return_value
= 2
2902 mock_existing_vol_availability
.return_value
= 3
2904 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2906 existing_vim_volumes
,
2909 block_device_mapping
,
2912 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2913 mock_created_vol_availability
.assert_called_once_with(0, created_items
)
2914 mock_existing_vol_availability
.assert_called_once_with(2, existing_vim_volumes
)
2915 mock_root_volumes
.assert_not_called()
2916 mock_non_root_volumes
.assert_not_called()
2918 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2919 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2920 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2921 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2922 def test_prepare_disk_for_vm_instance_persistent_root_volume_error(
2924 mock_existing_vol_availability
,
2925 mock_created_vol_availability
,
2926 mock_non_root_volumes
,
2929 """Persistent root volumes preparation raises error."""
2930 existing_vim_volumes
= []
2932 vm_av_zone
= ["nova"]
2933 block_device_mapping
= {}
2935 mock_root_volumes
.side_effect
= Exception()
2936 mock_created_vol_availability
.return_value
= 10
2937 mock_existing_vol_availability
.return_value
= 15
2939 with self
.assertRaises(Exception):
2940 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2942 existing_vim_volumes
,
2945 block_device_mapping
,
2948 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2949 mock_created_vol_availability
.assert_not_called()
2950 mock_existing_vol_availability
.assert_not_called()
2951 mock_root_volumes
.assert_called_once_with(
2953 vm_av_zone
=["nova"],
2954 disk
={"size": 10, "image_id": image_id
},
2956 block_device_mapping
={},
2957 existing_vim_volumes
=[],
2960 mock_non_root_volumes
.assert_not_called()
2962 @patch.object(vimconnector
, "_prepare_persistent_root_volumes")
2963 @patch.object(vimconnector
, "_prepare_non_root_persistent_volumes")
2964 @patch.object(vimconnector
, "_wait_for_created_volumes_availability")
2965 @patch.object(vimconnector
, "_wait_for_existing_volumes_availability")
2966 def test_prepare_disk_for_vm_instance_non_root_volume_error(
2968 mock_existing_vol_availability
,
2969 mock_created_vol_availability
,
2970 mock_non_root_volumes
,
2973 """Non-root volumes preparation raises error."""
2974 existing_vim_volumes
= []
2976 vm_av_zone
= ["nova"]
2977 block_device_mapping
= {}
2979 mock_root_volumes
.return_value
= root_vol_id
2980 mock_non_root_volumes
.side_effect
= Exception
2982 with self
.assertRaises(Exception):
2983 self
.vimconn
._prepare
_disk
_for
_vminstance
(
2985 existing_vim_volumes
,
2988 block_device_mapping
,
2991 self
.vimconn
.cinder
.volumes
.set_bootable
.assert_not_called()
2992 mock_created_vol_availability
.assert_not_called()
2993 mock_existing_vol_availability
.assert_not_called()
2994 self
.assertEqual(mock_root_volumes
.call_count
, 1)
2995 self
.assertEqual(mock_non_root_volumes
.call_count
, 1)
2996 mock_root_volumes
.assert_called_once_with(
2998 vm_av_zone
=["nova"],
2999 disk
={"size": 10, "image_id": image_id
},
3001 block_device_mapping
={},
3002 existing_vim_volumes
=[],
3005 mock_non_root_volumes
.assert_called_once_with(
3008 vm_av_zone
=["nova"],
3010 block_device_mapping
={},
3011 existing_vim_volumes
=[],
3015 def test_find_external_network_for_floating_ip_no_external_network(self
):
3016 """External network could not be found."""
3017 self
.vimconn
.neutron
.list_networks
.return_value
= {
3019 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": False}
3022 with self
.assertRaises(VimConnException
) as err
:
3023 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
3026 "Cannot create floating_ip automatically since no external network is present",
3029 def test_find_external_network_for_floating_one_external_network(self
):
3030 """One external network has been found."""
3031 self
.vimconn
.neutron
.list_networks
.return_value
= {
3033 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True}
3036 expected_result
= "408b73-r9cc-5a6a-a270-82cc4811bd4a"
3037 result
= self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
3038 self
.assertEqual(result
, expected_result
)
3040 def test_find_external_network_for_floating_neutron_raises_exception(self
):
3041 """Neutron list networks raises exception."""
3042 self
.vimconn
.neutron
.list_networks
.side_effect
= Exception
3043 with self
.assertRaises(Exception):
3044 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
3046 def test_find_external_network_for_floating_several_external_network(self
):
3047 """Several exernal networks has been found."""
3048 self
.vimconn
.neutron
.list_networks
.return_value
= {
3050 {"id": "408b73-r9cc-5a6a-a270-82cc4811bd4a", "router:external": True},
3051 {"id": "608b73-y9cc-5a6a-a270-12cc4811bd4a", "router:external": True},
3054 with self
.assertRaises(VimConnException
) as err
:
3055 self
.vimconn
._find
_the
_external
_network
_for
_floating
_ip
()
3058 "Cannot create floating_ip automatically since multiple external networks are present",
3061 def test_neutron_create_float_ip(self
):
3062 """Floating ip creation is successful."""
3063 param
= {"net_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a"}
3065 self
.vimconn
.neutron
.create_floatingip
.return_value
= {
3066 "floatingip": {"id": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3068 expected_created_items
= {
3069 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True
3071 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
3072 self
.assertEqual(created_items
, expected_created_items
)
3074 def test_neutron_create_float_ip_exception_occured(self
):
3075 """Floating ip could not be created."""
3078 "floating_network_id": "408b73-r9cc-5a6a-a270-p2cc4811bd9a",
3079 "tenant_id": "308b73-19cc-8a6a-a270-02cc4811bd9a",
3083 self
.vimconn
.neutron
= CopyingMock()
3084 self
.vimconn
.neutron
.create_floatingip
.side_effect
= Exception(
3085 "Neutron floating ip create exception occured."
3087 with self
.assertRaises(VimConnException
) as err
:
3088 self
.vimconn
._neutron
_create
_float
_ip
(param
, created_items
)
3089 self
.assertEqual(created_items
, {})
3092 "Exception: Cannot create new floating_ip Neutron floating ip create exception occured.",
3095 @patch.object(vimconnector
, "_neutron_create_float_ip")
3096 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
3097 def test_create_floating_ip_pool_id_available(
3098 self
, mock_find_ext_network
, mock_create_float_ip
3100 """Floating ip creation, ip pool is available."""
3101 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3105 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3106 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3109 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
3110 mock_find_ext_network
.assert_not_called()
3111 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
3113 @patch.object(vimconnector
, "_neutron_create_float_ip")
3114 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
3115 def test_create_floating_ip_finding_pool_id(
3116 self
, mock_find_ext_network
, mock_create_float_ip
3118 """Floating ip creation, pool id need to be found."""
3119 floating_network
= {"floating_ip": True}
3121 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
3124 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3125 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3128 self
.vimconn
._create
_floating
_ip
(floating_network
, self
.server
, created_items
)
3129 mock_find_ext_network
.assert_called_once()
3130 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
3132 @patch.object(vimconnector
, "_neutron_create_float_ip")
3133 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
3134 def test_create_floating_ip_neutron_create_floating_ip_exception(
3135 self
, mock_find_ext_network
, mock_create_float_ip
3137 """Neutron creat floating ip raises error."""
3138 floating_network
= {"floating_ip": True}
3140 mock_create_float_ip
.side_effect
= VimConnException(
3141 "Can not create floating ip."
3143 mock_find_ext_network
.return_value
= "308b73-t9cc-1a6a-a270-12cc4811bd4a"
3146 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3147 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3151 with self
.assertRaises(VimConnException
) as err
:
3152 self
.vimconn
._create
_floating
_ip
(
3153 floating_network
, self
.server
, created_items
3155 self
.assertEqual(str(err
.exception
), "Can not create floating ip.")
3156 mock_find_ext_network
.assert_called_once()
3157 mock_create_float_ip
.assert_called_once_with(expected_param
, {})
3159 @patch.object(vimconnector
, "_neutron_create_float_ip")
3160 @patch.object(vimconnector
, "_find_the_external_network_for_floating_ip")
3161 def test_create_floating_ip_can_not_find_pool_id(
3162 self
, mock_find_ext_network
, mock_create_float_ip
3164 """Floating ip creation, pool id could not be found."""
3165 floating_network
= {"floating_ip": True}
3167 mock_find_ext_network
.side_effect
= VimConnException(
3168 "Cannot create floating_ip automatically since no external network is present"
3170 with self
.assertRaises(VimConnException
) as err
:
3171 self
.vimconn
._create
_floating
_ip
(
3172 floating_network
, self
.server
, created_items
3176 "Cannot create floating_ip automatically since no external network is present",
3178 mock_find_ext_network
.assert_called_once()
3179 mock_create_float_ip
.assert_not_called()
3181 def test_find_floating_ip_get_free_floating_ip(self
):
3182 """Get free floating ips successfully."""
3185 "tenant_id": "408b73-r9cc-5a6a-a270-82cc4811bd4a",
3186 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3187 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3190 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3191 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3193 result
= self
.vimconn
._find
_floating
_ip
(
3194 self
.server
, floating_ips
, floating_network
3196 self
.assertEqual(result
, expected_result
)
3198 def test_find_floating_ip_different_floating_network_id(self
):
3199 """Floating network id is different with floating_ip of floating network."""
3202 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3203 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3206 floating_network
= {"floating_ip": "508b73-t9cc-1a6a-a270-12cc4811bd4a"}
3208 result
= self
.vimconn
._find
_floating
_ip
(
3209 self
.server
, floating_ips
, floating_network
3211 self
.assertEqual(result
, None)
3213 def test_find_floating_ip_different_fip_tenant(self
):
3214 """Items in floating_ips has port_id, tenant_is is not same with server tenant id."""
3217 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3218 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3219 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3220 "tenant_id": self
.server
.id,
3223 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3224 mock_create_floating_ip
= CopyingMock()
3225 with patch
.object(vimconnector
, "_create_floating_ip", mock_create_floating_ip
):
3226 result
= self
.vimconn
._find
_floating
_ip
(
3227 self
.server
, floating_ips
, floating_network
3229 self
.assertEqual(result
, None)
3231 @patch("time.sleep")
3232 def test_assign_floating_ip(self
, mock_sleep
):
3233 """Assign floating ip successfully."""
3234 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3235 floating_network
= {"vim_id": floating_network_vim_id
}
3237 "port_id": floating_network_vim_id
,
3238 "floating_network_id": "p08b73-e9cc-5a6a-t270-82cc4811bd4a",
3239 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3240 "tenant_id": "k08b73-e9cc-5a6a-t270-82cc4811bd4a",
3242 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
3243 self
.vimconn
.neutron
.show_floatingip
.return_value
= fip
3244 expected_result
= fip
3246 result
= self
.vimconn
._assign
_floating
_ip
(free_floating_ip
, floating_network
)
3247 self
.assertEqual(result
, expected_result
)
3248 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3250 {"floatingip": {"port_id": floating_network_vim_id
}},
3252 mock_sleep
.assert_called_once_with(5)
3253 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
3255 @patch("time.sleep")
3256 def test_assign_floating_ip_update_floating_ip_exception(self
, mock_sleep
):
3257 """Neutron update floating ip raises exception."""
3258 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3259 floating_network
= {"vim_id": floating_network_vim_id
}
3260 self
.vimconn
.neutron
= CopyingMock()
3261 self
.vimconn
.neutron
.update_floatingip
.side_effect
= Exception(
3262 "Floating ip is not updated."
3265 with self
.assertRaises(Exception) as err
:
3266 result
= self
.vimconn
._assign
_floating
_ip
(
3267 free_floating_ip
, floating_network
3269 self
.assertEqual(result
, None)
3270 self
.assertEqual(str(err
.exception
), "Floating ip is not updated.")
3272 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3274 {"floatingip": {"port_id": floating_network_vim_id
}},
3276 mock_sleep
.assert_not_called()
3277 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3279 @patch("time.sleep")
3280 def test_assign_floating_ip_show_floating_ip_exception(self
, mock_sleep
):
3281 """Neutron show floating ip raises exception."""
3282 free_floating_ip
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3283 floating_network
= {"vim_id": floating_network_vim_id
}
3284 self
.vimconn
.neutron
.update_floatingip
.side_effect
= None
3285 self
.vimconn
.neutron
.show_floatingip
.side_effect
= Exception(
3286 "Floating ip could not be shown."
3289 with self
.assertRaises(Exception) as err
:
3290 result
= self
.vimconn
._assign
_floating
_ip
(
3291 free_floating_ip
, floating_network
3293 self
.assertEqual(result
, None)
3294 self
.assertEqual(str(err
.exception
), "Floating ip could not be shown.")
3295 self
.vimconn
.neutron
.update_floatingip
.assert_called_once_with(
3297 {"floatingip": {"port_id": floating_network_vim_id
}},
3299 mock_sleep
.assert_called_once_with(5)
3300 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(free_floating_ip
)
3302 @patch("random.shuffle")
3303 @patch.object(vimconnector
, "_find_floating_ip")
3304 def test_get_free_floating_ip(self
, mock_find_floating_ip
, mock_shuffle
):
3305 """Get free floating ip successfully."""
3306 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3309 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3310 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3311 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3312 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3315 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3316 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3317 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3318 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3321 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
3322 "floatingips": floating_ips
3324 mock_find_floating_ip
.return_value
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3325 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3327 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3328 self
.assertEqual(result
, expected_result
)
3329 mock_shuffle
.assert_called_once_with(floating_ips
)
3330 mock_find_floating_ip
.assert_called_once_with(
3331 self
.server
, floating_ips
, floating_network
3334 @patch("random.shuffle")
3335 @patch.object(vimconnector
, "_find_floating_ip")
3336 def test_get_free_floating_ip_list_floating_ip_exception(
3337 self
, mock_find_floating_ip
, mock_shuffle
3339 """Neutron list floating IPs raises exception."""
3340 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3341 self
.vimconn
.neutron
= CopyingMock()
3342 self
.vimconn
.neutron
.list_floatingips
.side_effect
= Exception(
3343 "Floating ips could not be listed."
3345 with self
.assertRaises(Exception) as err
:
3346 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3347 self
.assertEqual(result
, None)
3348 self
.assertEqual(str(err
.exception
), "Floating ips could not be listed.")
3349 mock_shuffle
.assert_not_called()
3350 mock_find_floating_ip
.assert_not_called()
3352 @patch("random.shuffle")
3353 @patch.object(vimconnector
, "_find_floating_ip")
3354 def test_get_free_floating_ip_find_floating_ip_exception(
3355 self
, mock_find_floating_ip
, mock_shuffle
3357 """_find_floating_ip method raises exception."""
3358 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3361 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3362 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3363 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3364 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3367 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3368 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3369 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3370 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3373 self
.vimconn
.neutron
= CopyingMock()
3374 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
3375 "floatingips": floating_ips
3377 mock_find_floating_ip
.side_effect
= Exception(
3378 "Free floating ip could not be found."
3381 with self
.assertRaises(Exception) as err
:
3382 result
= self
.vimconn
._get
_free
_floating
_ip
(self
.server
, floating_network
)
3383 self
.assertEqual(result
, None)
3384 self
.assertEqual(str(err
.exception
), "Free floating ip could not be found.")
3385 mock_shuffle
.assert_called_once_with(floating_ips
)
3386 mock_find_floating_ip
.assert_called_once_with(
3387 self
.server
, floating_ips
, floating_network
3390 @patch.object(vimconnector
, "_create_floating_ip")
3391 @patch.object(vimconnector
, "_get_free_floating_ip")
3392 @patch.object(vimconnector
, "_assign_floating_ip")
3393 def test_prepare_external_network_for_vm_instance(
3395 mock_assign_floating_ip
,
3396 mock_get_free_floating_ip
,
3397 mock_create_floating_ip
,
3399 """Prepare external network successfully."""
3400 external_network
= [
3402 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3403 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3407 vm_start_time
= time_return_value
3408 mock_get_free_floating_ip
.side_effect
= ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
3409 mock_assign_floating_ip
.return_value
= {
3410 "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
3412 self
.vimconn
.neutron
= CopyingMock()
3413 self
.vimconn
.nova
= CopyingMock()
3414 self
.vimconn
.neutron
.show_floatingip
.return_value
= {
3415 "floatingip": {"port_id": ""}
3418 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3419 external_network
, self
.server
, created_items
, vm_start_time
3422 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3423 mock_get_free_floating_ip
.assert_called_once_with(
3426 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3427 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3430 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(
3431 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3433 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3434 mock_create_floating_ip
.assert_not_called()
3435 mock_assign_floating_ip
.assert_called_once_with(
3436 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3438 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3439 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
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_floating_ip(
3450 mock_assign_floating_ip
,
3451 mock_get_free_floating_ip
,
3452 mock_create_floating_ip
,
3456 """There is not any free floating ip."""
3457 floating_network
= {
3458 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3459 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3461 external_network
= [floating_network
]
3464 vm_start_time
= time_return_value
3465 mock_get_free_floating_ip
.return_value
= None
3466 mock_assign_floating_ip
.return_value
= {}
3467 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3468 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3470 with self
.assertRaises(KeyError):
3471 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3472 external_network
, self
.server
, created_items
, vm_start_time
3475 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3476 mock_get_free_floating_ip
.assert_called_with(
3479 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3480 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3483 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(None)
3484 mock_sleep
.assert_not_called()
3485 mock_time
.assert_not_called()
3486 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3487 mock_create_floating_ip
.assert_called_with(
3488 floating_network
, self
.server
, created_items
3490 self
.assertEqual(mock_create_floating_ip
.call_count
, 4)
3491 mock_assign_floating_ip
.assert_not_called()
3492 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3495 @patch("time.sleep")
3496 @patch.object(vimconnector
, "_create_floating_ip")
3497 @patch.object(vimconnector
, "_get_free_floating_ip")
3498 @patch.object(vimconnector
, "_assign_floating_ip")
3499 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
3501 mock_assign_floating_ip
,
3502 mock_get_free_floating_ip
,
3503 mock_create_floating_ip
,
3507 """There is not any free floating ip, create_floating ip method raise exception
3508 exit_on_floating_ip_error set to False."""
3509 floating_network
= {
3510 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3511 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3512 "exit_on_floating_ip_error": False,
3514 external_network
= [floating_network
]
3517 vm_start_time
= time_return_value
3518 mock_get_free_floating_ip
.return_value
= None
3519 mock_assign_floating_ip
.return_value
= {}
3520 mock_create_floating_ip
.side_effect
= VimConnException(
3521 "Can not create floating ip."
3523 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3524 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3526 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3527 external_network
, self
.server
, created_items
, vm_start_time
3529 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3530 mock_get_free_floating_ip
.assert_called_with(
3533 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3534 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3535 "exit_on_floating_ip_error": False,
3538 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3539 mock_sleep
.assert_not_called()
3540 mock_time
.assert_not_called()
3541 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3542 mock_create_floating_ip
.assert_called_with(
3543 floating_network
, self
.server
, created_items
3545 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
3546 mock_assign_floating_ip
.assert_not_called()
3549 @patch("time.sleep")
3550 @patch.object(vimconnector
, "_create_floating_ip")
3551 @patch.object(vimconnector
, "_get_free_floating_ip")
3552 @patch.object(vimconnector
, "_assign_floating_ip")
3553 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
3555 mock_assign_floating_ip
,
3556 mock_get_free_floating_ip
,
3557 mock_create_floating_ip
,
3561 """There is not any free floating ip, create_floating ip method raise exception
3562 exit_on_floating_ip_error set to False."""
3563 floating_network
= {
3564 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3565 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3566 "exit_on_floating_ip_error": True,
3568 external_network
= [floating_network
]
3571 vm_start_time
= time_return_value
3572 mock_get_free_floating_ip
.return_value
= None
3573 mock_assign_floating_ip
.return_value
= {}
3574 mock_create_floating_ip
.side_effect
= VimConnException(
3575 "Can not create floating ip."
3577 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3578 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3579 with self
.assertRaises(VimConnException
):
3580 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3581 external_network
, self
.server
, created_items
, vm_start_time
3583 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3584 mock_get_free_floating_ip
.assert_called_with(
3587 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3588 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3589 "exit_on_floating_ip_error": True,
3592 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3593 mock_sleep
.assert_not_called()
3594 mock_time
.assert_not_called()
3595 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3596 mock_create_floating_ip
.assert_called_with(
3597 floating_network
, self
.server
, created_items
3599 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
3600 mock_assign_floating_ip
.assert_not_called()
3602 @patch.object(vimconnector
, "_create_floating_ip")
3603 @patch.object(vimconnector
, "_get_free_floating_ip")
3604 @patch.object(vimconnector
, "_assign_floating_ip")
3605 def test_prepare_external_network_for_vm_instance_fip_has_port_id(
3607 mock_assign_floating_ip
,
3608 mock_get_free_floating_ip
,
3609 mock_create_floating_ip
,
3611 """Neutron show floating ip return the fip with port_id and floating network vim_id
3612 is different from port_id."""
3613 floating_network
= {
3614 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3615 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3617 external_network
= [floating_network
]
3620 mock_get_free_floating_ip
.side_effect
= [
3621 "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
3622 "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
3623 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3625 mock_assign_floating_ip
.side_effect
= [
3626 {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3627 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3629 self
.vimconn
.neutron
= CopyingMock()
3630 self
.vimconn
.nova
= CopyingMock()
3631 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3632 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3633 {"floatingip": {"port_id": ""}},
3634 {"floatingip": {"port_id": ""}},
3636 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3637 external_network
, self
.server
, created_items
, vm_start_time
3639 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3640 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3642 _call_mock_get_free_floating_ip
[0][0],
3649 _call_mock_get_free_floating_ip
[1][0],
3656 _call_mock_get_free_floating_ip
[2][0],
3662 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3663 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3664 mock_create_floating_ip
.assert_not_called()
3665 self
.assertEqual(mock_assign_floating_ip
.call_count
, 2)
3666 _call_mock_assign_floating_ip
= mock_assign_floating_ip
.call_args_list
3668 _call_mock_assign_floating_ip
[0][0],
3669 ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
3672 _call_mock_assign_floating_ip
[1][0],
3673 ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
3677 @patch("time.sleep")
3678 @patch.object(vimconnector
, "_create_floating_ip")
3679 @patch.object(vimconnector
, "_get_free_floating_ip")
3680 @patch.object(vimconnector
, "_assign_floating_ip")
3681 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
3683 mock_assign_floating_ip
,
3684 mock_get_free_floating_ip
,
3685 mock_create_floating_ip
,
3689 """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
3690 VM status is in error."""
3691 floating_network
= {
3692 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3693 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3694 "exit_on_floating_ip_error": True,
3696 external_network
= [floating_network
]
3698 vm_start_time
= time_return_value
3700 mock_time
.side_effect
= [156570150, 156570800, 156571200]
3702 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3703 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3704 Exception("Floating ip could not be shown.")
3706 with self
.assertRaises(Exception) as err
:
3707 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3708 external_network
, self
.server
, created_items
, vm_start_time
3712 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3715 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3716 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3718 _call_mock_get_free_floating_ip
[0][0],
3725 _call_mock_get_free_floating_ip
[1][0],
3732 _call_mock_get_free_floating_ip
[2][0],
3739 _call_mock_get_free_floating_ip
[3][0],
3746 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3747 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3748 mock_create_floating_ip
.assert_not_called()
3749 mock_assign_floating_ip
.assert_not_called()
3750 mock_time
.assert_not_called()
3751 mock_sleep
.assert_not_called()
3754 @patch("time.sleep")
3755 @patch.object(vimconnector
, "_create_floating_ip")
3756 @patch.object(vimconnector
, "_get_free_floating_ip")
3757 @patch.object(vimconnector
, "_assign_floating_ip")
3758 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
3760 mock_assign_floating_ip
,
3761 mock_get_free_floating_ip
,
3762 mock_create_floating_ip
,
3766 """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
3767 VM status is in active."""
3768 floating_network
= {
3769 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3770 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3771 "exit_on_floating_ip_error": False,
3773 external_network
= [floating_network
]
3775 vm_start_time
= time_return_value
3777 mock_time
.side_effect
= [156570150, 156570800, 156571200]
3779 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ACTIVE"
3780 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3781 Exception("Floating ip could not be shown.")
3784 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3785 external_network
, self
.server
, created_items
, vm_start_time
3787 # self.assertEqual(str(err.exception), "Cannot create floating_ip")
3789 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3790 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3792 _call_mock_get_free_floating_ip
[0][0],
3799 _call_mock_get_free_floating_ip
[1][0],
3806 _call_mock_get_free_floating_ip
[2][0],
3813 _call_mock_get_free_floating_ip
[3][0],
3820 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3821 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3822 mock_create_floating_ip
.assert_not_called()
3823 mock_assign_floating_ip
.assert_not_called()
3824 mock_time
.assert_not_called()
3825 mock_sleep
.assert_not_called()
3828 @patch("time.sleep")
3829 @patch.object(vimconnector
, "_create_floating_ip")
3830 @patch.object(vimconnector
, "_get_free_floating_ip")
3831 @patch.object(vimconnector
, "_assign_floating_ip")
3832 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
3834 mock_assign_floating_ip
,
3835 mock_get_free_floating_ip
,
3836 mock_create_floating_ip
,
3840 """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
3841 VM status is not ACTIVE or ERROR, server timeout happened."""
3842 floating_network
= {
3843 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3844 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3845 "exit_on_floating_ip_error": True,
3847 external_network
= [floating_network
]
3849 vm_start_time
= time_return_value
3850 mock_get_free_floating_ip
.side_effect
= None
3851 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3852 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "OTHER"
3853 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3854 Exception("Floating ip could not be shown.")
3857 with self
.assertRaises(VimConnException
) as err
:
3858 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3859 external_network
, self
.server
, created_items
, vm_start_time
3863 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3866 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3867 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3869 _call_mock_get_free_floating_ip
[0][0],
3876 _call_mock_get_free_floating_ip
[1][0],
3883 _call_mock_get_free_floating_ip
[2][0],
3890 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3891 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3892 mock_create_floating_ip
.assert_not_called()
3893 mock_assign_floating_ip
.assert_not_called()
3894 self
.assertEqual(mock_time
.call_count
, 3)
3895 self
.assertEqual(mock_sleep
.call_count
, 2)
3898 @patch("time.sleep")
3899 @patch.object(vimconnector
, "_create_floating_ip")
3900 @patch.object(vimconnector
, "_get_free_floating_ip")
3901 @patch.object(vimconnector
, "_assign_floating_ip")
3902 def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3904 mock_assign_floating_ip
,
3905 mock_get_free_floating_ip
,
3906 mock_create_floating_ip
,
3910 """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3911 VM status is in ERROR."""
3912 floating_network
= {
3913 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3914 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3915 "exit_on_floating_ip_error": True,
3917 external_network
= [floating_network
]
3919 vm_start_time
= time_return_value
3921 mock_get_free_floating_ip
.side_effect
= [
3922 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3925 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3927 mock_assign_floating_ip
.side_effect
= [
3928 Exception("Floating ip could not be assigned.")
3931 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3932 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3933 {"floatingip": {"port_id": ""}}
3936 with self
.assertRaises(VimConnException
) as err
:
3937 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3938 external_network
, self
.server
, created_items
, vm_start_time
3942 "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3945 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3946 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3948 _call_mock_get_free_floating_ip
[0][0],
3955 _call_mock_get_free_floating_ip
[1][0],
3962 _call_mock_get_free_floating_ip
[2][0],
3969 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3970 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(
3971 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3973 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3974 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3975 mock_time
.assert_not_called()
3976 mock_sleep
.assert_not_called()
3977 mock_create_floating_ip
.assert_not_called()
3980 @patch("time.sleep")
3981 @patch.object(vimconnector
, "_create_floating_ip")
3982 @patch.object(vimconnector
, "_get_free_floating_ip")
3983 @patch.object(vimconnector
, "_assign_floating_ip")
3984 def test_prepare_external_network_for_vm_instance_empty_external_network_list(
3986 mock_assign_floating_ip
,
3987 mock_get_free_floating_ip
,
3988 mock_create_floating_ip
,
3992 """External network list is empty."""
3993 external_network
= []
3995 vm_start_time
= time_return_value
3997 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3998 external_network
, self
.server
, created_items
, vm_start_time
4000 mock_create_floating_ip
.assert_not_called()
4001 mock_time
.assert_not_called()
4002 mock_sleep
.assert_not_called()
4003 mock_assign_floating_ip
.assert_not_called()
4004 mock_get_free_floating_ip
.assert_not_called()
4005 self
.vimconn
.neutron
.show
.show_floatingip
.assert_not_called()
4006 self
.vimconn
.nova
.servers
.get
.assert_not_called()
4008 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4009 def test_update_port_security_for_vm_instance(self
, mock_wait_for_vm
):
4010 """no_secured_ports has port and the port has allow-address-pairs."""
4011 no_secured_ports
= [(port2_id
, "allow-address-pairs")]
4013 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
4015 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
4017 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
4019 {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
4022 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4023 def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
4024 self
, mock_wait_for_vm
4026 """no_secured_ports has port and the port does not have allow-address-pairs."""
4027 no_secured_ports
= [(port2_id
, "something")]
4029 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
4031 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
4033 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
4035 {"port": {"port_security_enabled": False, "security_groups": None}},
4038 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4039 def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
4040 self
, mock_wait_for_vm
4042 """__wait_for_vm raises timeout exception."""
4043 no_secured_ports
= [(port2_id
, "something")]
4045 mock_wait_for_vm
.side_effect
= VimConnException("Timeout waiting for instance.")
4047 with self
.assertRaises(VimConnException
) as err
:
4048 self
.vimconn
._update
_port
_security
_for
_vminstance
(
4049 no_secured_ports
, self
.server
4051 self
.assertEqual(str(err
.exception
), "Timeout waiting for instance.")
4053 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
4055 self
.vimconn
.neutron
.update_port
.assert_not_called()
4057 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4058 def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
4059 self
, mock_wait_for_vm
4061 """neutron_update_port method raises exception."""
4062 no_secured_ports
= [(port2_id
, "something")]
4064 self
.vimconn
.neutron
.update_port
.side_effect
= Exception(
4065 "Port security could not be updated."
4068 with self
.assertRaises(VimConnException
) as err
:
4069 self
.vimconn
._update
_port
_security
_for
_vminstance
(
4070 no_secured_ports
, self
.server
4074 "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
4076 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
4078 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
4080 {"port": {"port_security_enabled": False, "security_groups": None}},
4083 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4084 def test_update_port_security_for_vm_instance_empty_port_list(
4085 self
, mock_wait_for_vm
4087 """no_secured_ports list does not have any ports."""
4088 no_secured_ports
= []
4090 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
4092 mock_wait_for_vm
.assert_not_called()
4094 self
.vimconn
.neutron
.update_port
.assert_not_called()
4097 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4098 @patch.object(vimconnector
, "_reload_connection")
4099 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4100 @patch.object(vimconnector
, "_create_user_data")
4101 @patch.object(vimconnector
, "_get_vm_availability_zone")
4102 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4103 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4104 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4105 @patch.object(vimconnector
, "delete_vminstance")
4106 @patch.object(vimconnector
, "_format_exception")
4107 def test_new_vm_instance(
4109 mock_format_exception
,
4110 mock_delete_vm_instance
,
4111 mock_prepare_external_network
,
4112 mock_update_port_security
,
4113 mock_prepare_disk_for_vm_instance
,
4114 mock_get_vm_availability_zone
,
4115 mock_create_user_data
,
4116 mock_prepare_network_for_vm_instance
,
4117 mock_reload_connection
,
4118 mock_remove_keep_flag_from_persistent_volumes
,
4121 """New VM instance creation is successful."""
4123 mock_create_user_data
.return_value
= True, "userdata"
4125 mock_get_vm_availability_zone
.return_value
= "nova"
4127 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4129 mock_time
.return_value
= time_return_value
4131 expected_result
= self
.server
.id, {}
4133 result
= self
.vimconn
.new_vminstance(
4139 affinity_group_list
,
4143 availability_zone_index
,
4144 availability_zone_list
,
4146 self
.assertEqual(result
, expected_result
)
4148 mock_reload_connection
.assert_called_once()
4149 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4154 external_network
=[],
4155 no_secured_ports
=[],
4157 mock_create_user_data
.assert_called_once_with(cloud_config
)
4158 mock_get_vm_availability_zone
.assert_called_once_with(
4159 availability_zone_index
, availability_zone_list
4161 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4163 existing_vim_volumes
=[],
4166 block_device_mapping
={},
4167 disk_list
=disk_list2
,
4169 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4174 security_groups
="default",
4175 availability_zone
="nova",
4176 key_name
="my_keypair",
4177 userdata
="userdata",
4179 block_device_mapping
={},
4182 mock_time
.assert_called_once()
4183 mock_update_port_security
.assert_called_once_with([], self
.server
)
4184 mock_prepare_external_network
.assert_called_once_with(
4185 external_network
=[],
4188 vm_start_time
=time_return_value
,
4190 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
4191 mock_delete_vm_instance
.assert_not_called()
4192 mock_format_exception
.assert_not_called()
4195 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4196 @patch.object(vimconnector
, "_reload_connection")
4197 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4198 @patch.object(vimconnector
, "_create_user_data")
4199 @patch.object(vimconnector
, "_get_vm_availability_zone")
4200 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4201 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4202 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4203 @patch.object(vimconnector
, "delete_vminstance")
4204 @patch.object(vimconnector
, "_format_exception")
4205 def test_new_vm_instance_create_user_data_fails(
4207 mock_format_exception
,
4208 mock_delete_vm_instance
,
4209 mock_prepare_external_network
,
4210 mock_update_port_security
,
4211 mock_prepare_disk_for_vm_instance
,
4212 mock_get_vm_availability_zone
,
4213 mock_create_user_data
,
4214 mock_prepare_network_for_vm_instance
,
4215 mock_reload_connection
,
4216 mock_remove_keep_flag_from_persistent_volumes
,
4219 """New VM instance creation failed because of user data creation failure."""
4221 mock_create_user_data
.side_effect
= Exception(
4222 "User data could not be retrieved."
4225 mock_get_vm_availability_zone
.return_value
= "nova"
4227 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
4229 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4231 mock_time
.return_value
= time_return_value
4233 self
.vimconn
.new_vminstance(
4239 affinity_group_list
,
4243 availability_zone_index
,
4244 availability_zone_list
,
4247 mock_reload_connection
.assert_called_once()
4248 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4253 external_network
=[],
4254 no_secured_ports
=[],
4256 mock_create_user_data
.assert_called_once_with(cloud_config
)
4257 mock_get_vm_availability_zone
.assert_not_called()
4258 mock_prepare_disk_for_vm_instance
.assert_not_called()
4259 self
.vimconn
.nova
.servers
.create
.assert_not_called()
4260 mock_time
.assert_not_called()
4261 mock_update_port_security
.assert_not_called()
4262 mock_prepare_external_network
.assert_not_called()
4263 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
4264 mock_delete_vm_instance
.assert_called_once_with(None, {})
4265 mock_format_exception
.assert_called_once()
4266 arg
= mock_format_exception
.call_args
[0][0]
4267 self
.assertEqual(str(arg
), "User data could not be retrieved.")
4270 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4271 @patch.object(vimconnector
, "_reload_connection")
4272 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4273 @patch.object(vimconnector
, "_create_user_data")
4274 @patch.object(vimconnector
, "_get_vm_availability_zone")
4275 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4276 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4277 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4278 @patch.object(vimconnector
, "delete_vminstance")
4279 @patch.object(vimconnector
, "_format_exception")
4280 def test_new_vm_instance_external_network_exception(
4282 mock_format_exception
,
4283 mock_delete_vm_instance
,
4284 mock_prepare_external_network
,
4285 mock_update_port_security
,
4286 mock_prepare_disk_for_vm_instance
,
4287 mock_get_vm_availability_zone
,
4288 mock_create_user_data
,
4289 mock_prepare_network_for_vm_instance
,
4290 mock_reload_connection
,
4291 mock_remove_keep_flag_from_persistent_volumes
,
4294 """New VM instance creation, external network connection has failed as floating
4295 ip could not be created."""
4297 mock_create_user_data
.return_value
= True, "userdata"
4299 mock_get_vm_availability_zone
.return_value
= "nova"
4301 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4303 mock_time
.return_value
= time_return_value
4305 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
4307 mock_prepare_external_network
.side_effect
= VimConnException(
4308 "Can not create floating ip."
4311 self
.vimconn
.new_vminstance(
4317 affinity_group_list
,
4321 availability_zone_index
,
4322 availability_zone_list
,
4325 mock_reload_connection
.assert_called_once()
4326 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4331 external_network
=[],
4332 no_secured_ports
=[],
4334 mock_create_user_data
.assert_called_once_with(cloud_config
)
4335 mock_get_vm_availability_zone
.assert_called_once_with(
4336 availability_zone_index
, availability_zone_list
4338 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4340 existing_vim_volumes
=[],
4343 block_device_mapping
={},
4344 disk_list
=disk_list2
,
4346 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4351 security_groups
="default",
4352 availability_zone
="nova",
4353 key_name
="my_keypair",
4354 userdata
="userdata",
4356 block_device_mapping
={},
4359 mock_time
.assert_called_once()
4360 mock_update_port_security
.assert_called_once_with([], self
.server
)
4361 mock_prepare_external_network
.assert_called_once_with(
4362 external_network
=[],
4365 vm_start_time
=time_return_value
,
4367 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
4368 mock_delete_vm_instance
.assert_called_once_with(self
.server
.id, {})
4369 mock_format_exception
.assert_called_once()
4370 arg
= mock_format_exception
.call_args
[0][0]
4371 self
.assertEqual(str(arg
), "Can not create floating ip.")
4374 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4375 @patch.object(vimconnector
, "_reload_connection")
4376 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4377 @patch.object(vimconnector
, "_create_user_data")
4378 @patch.object(vimconnector
, "_get_vm_availability_zone")
4379 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4380 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4381 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4382 @patch.object(vimconnector
, "delete_vminstance")
4383 @patch.object(vimconnector
, "_format_exception")
4384 def test_new_vm_instance_with_affinity_group(
4386 mock_format_exception
,
4387 mock_delete_vm_instance
,
4388 mock_prepare_external_network
,
4389 mock_update_port_security
,
4390 mock_prepare_disk_for_vm_instance
,
4391 mock_get_vm_availability_zone
,
4392 mock_create_user_data
,
4393 mock_prepare_network_for_vm_instance
,
4394 mock_reload_connection
,
4395 mock_remove_keep_flag_from_persistent_volumes
,
4398 """New VM creation with affinity group."""
4399 affinity_group_list
= [
4400 {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
4402 mock_create_user_data
.return_value
= True, "userdata"
4403 mock_get_vm_availability_zone
.return_value
= "nova"
4404 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4405 mock_time
.return_value
= time_return_value
4406 expected_result
= self
.server
.id, {}
4408 result
= self
.vimconn
.new_vminstance(
4414 affinity_group_list
,
4418 availability_zone_index
,
4419 availability_zone_list
,
4421 self
.assertEqual(result
, expected_result
)
4423 mock_reload_connection
.assert_called_once()
4424 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4429 external_network
=[],
4430 no_secured_ports
=[],
4432 mock_create_user_data
.assert_called_once_with(cloud_config
)
4433 mock_get_vm_availability_zone
.assert_called_once_with(
4434 availability_zone_index
, availability_zone_list
4436 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4438 existing_vim_volumes
=[],
4441 block_device_mapping
={},
4442 disk_list
=disk_list2
,
4444 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4449 security_groups
="default",
4450 availability_zone
="nova",
4451 key_name
="my_keypair",
4452 userdata
="userdata",
4454 block_device_mapping
={},
4455 scheduler_hints
={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
4457 mock_time
.assert_called_once()
4458 mock_update_port_security
.assert_called_once_with([], self
.server
)
4459 mock_prepare_external_network
.assert_called_once_with(
4460 external_network
=[],
4463 vm_start_time
=time_return_value
,
4465 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
4466 mock_delete_vm_instance
.assert_not_called()
4467 mock_format_exception
.assert_not_called()
4470 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4471 @patch.object(vimconnector
, "_reload_connection")
4472 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4473 @patch.object(vimconnector
, "_create_user_data")
4474 @patch.object(vimconnector
, "_get_vm_availability_zone")
4475 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4476 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4477 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4478 @patch.object(vimconnector
, "delete_vminstance")
4479 @patch.object(vimconnector
, "_format_exception")
4480 def test_new_vm_instance_nova_server_create_failed(
4482 mock_format_exception
,
4483 mock_delete_vm_instance
,
4484 mock_prepare_external_network
,
4485 mock_update_port_security
,
4486 mock_prepare_disk_for_vm_instance
,
4487 mock_get_vm_availability_zone
,
4488 mock_create_user_data
,
4489 mock_prepare_network_for_vm_instance
,
4490 mock_reload_connection
,
4491 mock_remove_keep_flag_from_persistent_volumes
,
4494 """New VM(server) creation failed."""
4496 mock_create_user_data
.return_value
= True, "userdata"
4498 mock_get_vm_availability_zone
.return_value
= "nova"
4500 self
.vimconn
.nova
.servers
.create
.side_effect
= Exception(
4501 "Server could not be created."
4504 mock_time
.return_value
= time_return_value
4506 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
4508 self
.vimconn
.new_vminstance(
4514 affinity_group_list
,
4518 availability_zone_index
,
4519 availability_zone_list
,
4522 mock_reload_connection
.assert_called_once()
4523 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4528 external_network
=[],
4529 no_secured_ports
=[],
4531 mock_create_user_data
.assert_called_once_with(cloud_config
)
4532 mock_get_vm_availability_zone
.assert_called_once_with(
4533 availability_zone_index
, availability_zone_list
4535 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4537 existing_vim_volumes
=[],
4540 block_device_mapping
={},
4541 disk_list
=disk_list2
,
4544 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4549 security_groups
="default",
4550 availability_zone
="nova",
4551 key_name
="my_keypair",
4552 userdata
="userdata",
4554 block_device_mapping
={},
4557 mock_time
.assert_not_called()
4558 mock_update_port_security
.assert_not_called()
4559 mock_prepare_external_network
.assert_not_called()
4560 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
4561 mock_delete_vm_instance
.assert_called_once_with(None, {})
4562 mock_format_exception
.assert_called_once()
4563 arg
= mock_format_exception
.call_args
[0][0]
4564 self
.assertEqual(str(arg
), "Server could not be created.")
4567 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4568 @patch.object(vimconnector
, "_reload_connection")
4569 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4570 @patch.object(vimconnector
, "_create_user_data")
4571 @patch.object(vimconnector
, "_get_vm_availability_zone")
4572 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4573 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4574 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4575 @patch.object(vimconnector
, "delete_vminstance")
4576 @patch.object(vimconnector
, "_format_exception")
4577 def test_new_vm_instance_connection_exception(
4579 mock_format_exception
,
4580 mock_delete_vm_instance
,
4581 mock_prepare_external_network
,
4582 mock_update_port_security
,
4583 mock_prepare_disk_for_vm_instance
,
4584 mock_get_vm_availability_zone
,
4585 mock_create_user_data
,
4586 mock_prepare_network_for_vm_instance
,
4587 mock_reload_connection
,
4588 mock_remove_keep_flag_from_persistent_volumes
,
4591 """Connection to Cloud API has failed."""
4592 mock_reload_connection
.side_effect
= Exception("Can not connect to Cloud APIs.")
4593 mock_create_user_data
.return_value
= True, "userdata"
4594 mock_get_vm_availability_zone
.return_value
= "nova"
4595 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4596 mock_time
.return_value
= time_return_value
4597 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
4599 self
.vimconn
.new_vminstance(
4605 affinity_group_list
,
4609 availability_zone_index
,
4610 availability_zone_list
,
4612 mock_format_exception
.assert_called_once()
4613 arg
= mock_format_exception
.call_args
[0][0]
4614 self
.assertEqual(str(arg
), "Can not connect to Cloud APIs.")
4615 mock_reload_connection
.assert_called_once()
4616 mock_prepare_network_for_vm_instance
.assert_not_called()
4617 mock_create_user_data
.assert_not_called()
4618 mock_get_vm_availability_zone
.assert_not_called()
4619 mock_prepare_disk_for_vm_instance
.assert_not_called()
4620 self
.vimconn
.nova
.servers
.create
.assert_not_called()
4621 mock_time
.assert_not_called()
4622 mock_update_port_security
.assert_not_called()
4623 mock_prepare_external_network
.assert_not_called()
4624 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
4625 mock_delete_vm_instance
.assert_called_once_with(None, {})
4627 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4628 def test_delete_vm_ports_attached_to_network_empty_created_items(
4629 self
, mock_delete_ports_by_id_wth_neutron
4631 """Created_items is emtpty."""
4633 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4634 self
.vimconn
.neutron
.list_ports
.assert_not_called()
4635 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4636 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4638 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4639 def test_delete_vm_ports_attached_to_network(
4640 self
, mock_delete_ports_by_id_wth_neutron
4643 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
4644 f
"volume:{volume_id2}": True,
4645 f
"volume:{volume_id}": True,
4646 f
"port:{port_id}": True,
4648 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4649 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4650 self
.vimconn
.logger
.error
.assert_not_called()
4652 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4653 def test_delete_vm_ports_attached_to_network_wthout_port(
4654 self
, mock_delete_ports_by_id_wth_neutron
4656 """Created_items does not have port."""
4658 f
"floating_ip:{floating_network_vim_id}": True,
4659 f
"volume:{volume_id2}": True,
4660 f
"volume:{volume_id}": True,
4662 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4663 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4664 self
.vimconn
.logger
.error
.assert_not_called()
4666 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4667 def test_delete_vm_ports_attached_to_network_delete_port_raise_vimconnexception(
4668 self
, mock_delete_ports_by_id_wth_neutron
4670 """_delete_ports_by_id_wth_neutron raises vimconnexception."""
4671 created_items
= deepcopy(created_items_all_true
)
4672 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
4673 "Can not delete port"
4675 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4676 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4677 self
.vimconn
.logger
.error
.assert_called_once_with(
4678 "Error deleting port: VimConnException: Can not delete port"
4681 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4682 def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
4683 self
, mock_delete_ports_by_id_wth_neutron
4685 """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
4686 created_items
= deepcopy(created_items_all_true
)
4687 mock_delete_ports_by_id_wth_neutron
.side_effect
= nvExceptions
.ClientException(
4688 "Connection aborted."
4690 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4691 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4692 self
.vimconn
.logger
.error
.assert_called_once_with(
4693 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4696 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4697 def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
4698 self
, mock_delete_ports_by_id_wth_neutron
4700 """port item is invalid."""
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}:": True,
4707 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
4708 "Port is not valid."
4710 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4711 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}:")
4712 self
.vimconn
.logger
.error
.assert_called_once_with(
4713 "Error deleting port: VimConnException: Port is not valid."
4716 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4717 def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
4718 self
, mock_delete_ports_by_id_wth_neutron
4720 """port is already deleted."""
4722 f
"floating_ip:{floating_network_vim_id}": True,
4723 f
"volume:{volume_id2}": True,
4724 f
"volume:{volume_id}": None,
4725 f
"port:{port_id}": None,
4727 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4728 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4729 self
.vimconn
.logger
.error
.assert_not_called()
4731 def test_delete_floating_ip_by_id(self
):
4733 f
"floating_ip:{floating_network_vim_id}": True,
4734 f
"port:{port_id}": True,
4736 expected_created_items
= {
4737 f
"floating_ip:{floating_network_vim_id}": None,
4738 f
"port:{port_id}": True,
4740 k_id
= floating_network_vim_id
4741 k
= f
"floating_ip:{floating_network_vim_id}"
4742 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4743 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4744 self
.assertEqual(created_items
, expected_created_items
)
4746 def test_delete_floating_ip_by_id_floating_ip_already_deleted(self
):
4747 """floating ip is already deleted."""
4749 f
"floating_ip:{floating_network_vim_id}": None,
4750 f
"port:{port_id}": True,
4752 k_id
= floating_network_vim_id
4753 k
= f
"floating_ip:{floating_network_vim_id}"
4754 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4755 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4759 f
"floating_ip:{floating_network_vim_id}": None,
4760 f
"port:{port_id}": True,
4764 def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self
):
4765 """netron delete floating ip raises nvExceptions.ClientException."""
4767 f
"floating_ip:{floating_network_vim_id}": True,
4768 f
"port:{port_id}": True,
4770 k_id
= floating_network_vim_id
4771 k
= f
"floating_ip:{floating_network_vim_id}"
4772 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= (
4773 nvExceptions
.ClientException("Client exception occured.")
4775 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4776 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4780 f
"floating_ip:{floating_network_vim_id}": True,
4781 f
"port:{port_id}": True,
4784 self
.vimconn
.logger
.error
.assert_called_once_with(
4785 "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occured.)"
4788 def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self
):
4789 """netron delete floating ip raises VimConnNotFoundException."""
4791 f
"floating_ip:{floating_network_vim_id}": True,
4792 f
"port:{port_id}": True,
4794 k_id
= floating_network_vim_id
4795 k
= f
"floating_ip:{floating_network_vim_id}"
4796 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= VimConnNotFoundException(
4797 "Port id could not found."
4799 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4800 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4804 f
"floating_ip:{floating_network_vim_id}": True,
4805 f
"port:{port_id}": True,
4808 self
.vimconn
.logger
.error
.assert_called_once_with(
4809 "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
4812 def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self
):
4813 """invalid floating ip item."""
4815 f
"floating_ip:{floating_network_vim_id}": True,
4816 f
"port:{port_id}": True,
4818 expected_created_items
= {
4819 f
"floating_ip:{floating_network_vim_id}::": None,
4820 f
"floating_ip:{floating_network_vim_id}": True,
4821 f
"port:{port_id}": True,
4823 k_id
= floating_network_vim_id
4824 k
= f
"floating_ip:{floating_network_vim_id}::"
4825 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4826 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4827 self
.assertEqual(created_items
, expected_created_items
)
4829 def test_delete_volumes_by_id_with_cinder_volume_status_available(self
):
4830 """volume status is available."""
4832 f
"floating_ip:{floating_network_vim_id}": True,
4833 f
"volume:{volume_id2}": True,
4834 f
"volume:{volume_id}": True,
4835 f
"port:{port_id}": None,
4837 expected_created_items
= {
4838 f
"floating_ip:{floating_network_vim_id}": True,
4839 f
"volume:{volume_id2}": True,
4840 f
"volume:{volume_id}": None,
4841 f
"port:{port_id}": None,
4843 volumes_to_hold
= []
4844 k
= f
"volume:{volume_id}"
4846 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4847 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4848 k
, k_id
, volumes_to_hold
, created_items
4850 self
.assertEqual(result
, None)
4851 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4852 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4853 self
.vimconn
.logger
.error
.assert_not_called()
4854 self
.assertEqual(created_items
, expected_created_items
)
4856 def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self
):
4857 """volume is already deleted."""
4859 f
"floating_ip:{floating_network_vim_id}": True,
4860 f
"volume:{volume_id2}": True,
4861 f
"volume:{volume_id}": None,
4862 f
"port:{port_id}": None,
4864 expected_created_items
= {
4865 f
"floating_ip:{floating_network_vim_id}": True,
4866 f
"volume:{volume_id2}": True,
4867 f
"volume:{volume_id}": None,
4868 f
"port:{port_id}": None,
4870 volumes_to_hold
= []
4871 k
= f
"volume:{volume_id}"
4873 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4874 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4875 k
, k_id
, volumes_to_hold
, created_items
4877 self
.assertEqual(result
, None)
4878 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4879 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4880 self
.vimconn
.logger
.error
.assert_not_called()
4881 self
.assertEqual(created_items
, expected_created_items
)
4883 def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self
):
4884 """cinder get volume raises exception."""
4886 f
"floating_ip:{floating_network_vim_id}": True,
4887 f
"volume:{volume_id2}": True,
4888 f
"volume:{volume_id}": True,
4889 f
"port:{port_id}": None,
4891 expected_created_items
= {
4892 f
"floating_ip:{floating_network_vim_id}": True,
4893 f
"volume:{volume_id2}": True,
4894 f
"volume:{volume_id}": True,
4895 f
"port:{port_id}": None,
4897 volumes_to_hold
= []
4898 k
= f
"volume:{volume_id}"
4900 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception(
4901 "Can not get volume status."
4903 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4904 k
, k_id
, volumes_to_hold
, created_items
4906 self
.assertEqual(result
, None)
4907 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4908 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4909 self
.vimconn
.logger
.error
.assert_called_once_with(
4910 "Error deleting volume: Exception: Can not get volume status."
4912 self
.assertEqual(created_items
, expected_created_items
)
4914 def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self
):
4915 """cinder delete volume raises exception."""
4917 f
"floating_ip:{floating_network_vim_id}": True,
4918 f
"volume:{volume_id2}": True,
4919 f
"volume:{volume_id}": True,
4920 f
"port:{port_id}": None,
4922 expected_created_items
= {
4923 f
"floating_ip:{floating_network_vim_id}": True,
4924 f
"volume:{volume_id2}": True,
4925 f
"volume:{volume_id}": True,
4926 f
"port:{port_id}": None,
4928 volumes_to_hold
= []
4929 k
= f
"volume:{volume_id}"
4931 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4932 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= nvExceptions
.ClientException(
4933 "Connection aborted."
4935 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4936 k
, k_id
, volumes_to_hold
, created_items
4938 self
.assertEqual(result
, None)
4939 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4940 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4941 self
.vimconn
.logger
.error
.assert_called_once_with(
4942 "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
4944 self
.assertEqual(created_items
, expected_created_items
)
4946 def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self
):
4947 """volume_to_hold has item."""
4949 f
"floating_ip:{floating_network_vim_id}": True,
4950 f
"volume:{volume_id2}": True,
4951 f
"volume:{volume_id}": True,
4952 f
"port:{port_id}": None,
4954 expected_created_items
= {
4955 f
"floating_ip:{floating_network_vim_id}": True,
4956 f
"volume:{volume_id2}": True,
4957 f
"volume:{volume_id}": True,
4958 f
"port:{port_id}": None,
4960 volumes_to_hold
= [volume_id
]
4961 k
= f
"volume:{volume_id}"
4963 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4964 k
, k_id
, volumes_to_hold
, created_items
4966 self
.assertEqual(result
, None)
4967 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
4968 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4969 self
.vimconn
.logger
.error
.assert_not_called()
4970 self
.assertEqual(created_items
, expected_created_items
)
4972 def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self
):
4973 """volume status is not available."""
4975 f
"floating_ip:{floating_network_vim_id}": True,
4976 f
"volume:{volume_id2}": True,
4977 f
"volume:{volume_id}": True,
4978 f
"port:{port_id}": None,
4980 expected_created_items
= {
4981 f
"floating_ip:{floating_network_vim_id}": True,
4982 f
"volume:{volume_id2}": True,
4983 f
"volume:{volume_id}": True,
4984 f
"port:{port_id}": None,
4986 volumes_to_hold
= []
4987 k
= f
"volume:{volume_id}"
4989 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "unavailable"
4990 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4991 k
, k_id
, volumes_to_hold
, created_items
4993 self
.assertEqual(result
, True)
4994 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4995 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4996 self
.vimconn
.logger
.error
.assert_not_called()
4997 self
.assertEqual(created_items
, expected_created_items
)
4999 def test_delete_ports_by_id_by_neutron(self
):
5000 """neutron delete ports."""
5002 self
.vimconn
.neutron
.list_ports
.return_value
= {
5003 "ports": [{"id": port_id
}, {"id": port2_id
}]
5006 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
5007 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5008 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
5009 self
.vimconn
.logger
.error
.assert_not_called()
5011 def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self
):
5012 """port id not in the port list."""
5014 self
.vimconn
.neutron
.list_ports
.return_value
= {
5015 "ports": [{"id": port_id
}, {"id": port2_id
}]
5018 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
5019 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5020 self
.vimconn
.neutron
.delete_port
.assert_not_called()
5021 self
.vimconn
.logger
.error
.assert_not_called()
5023 def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self
):
5024 """neutron list port raises exception."""
5026 self
.vimconn
.neutron
.list_ports
.side_effect
= nvExceptions
.ClientException(
5027 "Connection aborted."
5029 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
5030 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5031 self
.vimconn
.neutron
.delete_port
.assert_not_called()
5032 self
.vimconn
.logger
.error
.assert_called_once_with(
5033 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
5036 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
5037 """neutron delete port raises exception."""
5039 self
.vimconn
.neutron
.list_ports
.return_value
= {
5040 "ports": [{"id": port_id
}, {"id": port2_id
}]
5042 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
5043 "Connection aborted."
5045 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
5046 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5047 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
5048 self
.vimconn
.logger
.error
.assert_called_once_with(
5049 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
5052 def test_get_item_name_id(self
):
5053 """Get name and id successfully."""
5054 k
= f
"some:{port_id}"
5055 result
= self
.vimconn
._get
_item
_name
_id
(k
)
5056 self
.assertEqual(result
, ("some", f
"{port_id}"))
5058 def test_get_item_name_id_wthout_semicolon(self
):
5059 """Does not have seperator."""
5060 k
= f
"some{port_id}"
5061 result
= self
.vimconn
._get
_item
_name
_id
(k
)
5062 self
.assertEqual(result
, (f
"some{port_id}", ""))
5064 def test_get_item_name_id_empty_string(self
):
5067 result
= self
.vimconn
._get
_item
_name
_id
(k
)
5068 self
.assertEqual(result
, ("", ""))
5070 def test_get_item_name_id_k_is_none(self
):
5073 with self
.assertRaises(AttributeError):
5074 self
.vimconn
._get
_item
_name
_id
(k
)
5076 @patch.object(vimconnector
, "_get_item_name_id")
5077 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5078 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5079 def test_delete_created_items(
5081 mock_delete_floating_ip_by_id
,
5082 mock_delete_volumes_by_id_wth_cinder
,
5083 mock_get_item_name_id
,
5085 """Created items has floating ip and volume."""
5087 f
"floating_ip:{floating_network_vim_id}": True,
5088 f
"volume:{volume_id}": True,
5089 f
"port:{port_id}": None,
5091 mock_get_item_name_id
.side_effect
= [
5092 ("floating_ip", f
"{floating_network_vim_id}"),
5093 ("volume", f
"{volume_id}"),
5095 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
5096 volumes_to_hold
= []
5097 keep_waiting
= False
5098 result
= self
.vimconn
._delete
_created
_items
(
5099 created_items
, volumes_to_hold
, keep_waiting
5101 self
.assertEqual(result
, True)
5102 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5103 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5104 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5106 mock_delete_floating_ip_by_id
.assert_called_once_with(
5107 f
"floating_ip:{floating_network_vim_id}",
5108 f
"{floating_network_vim_id}",
5111 self
.vimconn
.logger
.error
.assert_not_called()
5113 @patch.object(vimconnector
, "_get_item_name_id")
5114 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5115 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5116 def test_delete_created_items_wth_volumes_to_hold(
5118 mock_delete_floating_ip_by_id
,
5119 mock_delete_volumes_by_id_wth_cinder
,
5120 mock_get_item_name_id
,
5122 """Created items has floating ip and volume and volumes_to_hold has items."""
5124 f
"floating_ip:{floating_network_vim_id}": True,
5125 f
"volume:{volume_id}": True,
5126 f
"port:{port_id}": None,
5128 mock_get_item_name_id
.side_effect
= [
5129 ("floating_ip", f
"{floating_network_vim_id}"),
5130 ("volume", f
"{volume_id}"),
5132 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
5133 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5134 keep_waiting
= False
5135 result
= self
.vimconn
._delete
_created
_items
(
5136 created_items
, volumes_to_hold
, keep_waiting
5138 self
.assertEqual(result
, True)
5139 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5140 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5141 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
5143 mock_delete_floating_ip_by_id
.assert_called_once_with(
5144 f
"floating_ip:{floating_network_vim_id}",
5145 f
"{floating_network_vim_id}",
5148 self
.vimconn
.logger
.error
.assert_not_called()
5150 @patch.object(vimconnector
, "_get_item_name_id")
5151 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5152 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5153 def test_delete_created_items_wth_keep_waiting_true(
5155 mock_delete_floating_ip_by_id
,
5156 mock_delete_volumes_by_id_wth_cinder
,
5157 mock_get_item_name_id
,
5159 """Keep waiting initial value is True."""
5161 f
"floating_ip:{floating_network_vim_id}": True,
5162 f
"volume:{volume_id}": True,
5163 f
"port:{port_id}": None,
5165 mock_get_item_name_id
.side_effect
= [
5166 ("floating_ip", f
"{floating_network_vim_id}"),
5167 ("volume", f
"{volume_id}"),
5169 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5170 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5172 result
= self
.vimconn
._delete
_created
_items
(
5173 created_items
, volumes_to_hold
, keep_waiting
5175 self
.assertEqual(result
, True)
5176 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5177 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5178 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
5180 mock_delete_floating_ip_by_id
.assert_called_once_with(
5181 f
"floating_ip:{floating_network_vim_id}",
5182 f
"{floating_network_vim_id}",
5185 self
.vimconn
.logger
.error
.assert_not_called()
5187 @patch.object(vimconnector
, "_get_item_name_id")
5188 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5189 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5190 def test_delete_created_items_delete_vol_raises(
5192 mock_delete_floating_ip_by_id
,
5193 mock_delete_volumes_by_id_wth_cinder
,
5194 mock_get_item_name_id
,
5196 """Delete volume raises exception."""
5198 f
"floating_ip:{floating_network_vim_id}": True,
5199 f
"volume:{volume_id}": True,
5200 f
"port:{port_id}": None,
5202 mock_get_item_name_id
.side_effect
= [
5203 ("floating_ip", f
"{floating_network_vim_id}"),
5204 ("volume", f
"{volume_id}"),
5206 mock_delete_volumes_by_id_wth_cinder
.side_effect
= ConnectionError(
5207 "Connection failed."
5209 volumes_to_hold
= []
5210 keep_waiting
= False
5211 result
= self
.vimconn
._delete
_created
_items
(
5212 created_items
, volumes_to_hold
, keep_waiting
5214 self
.assertEqual(result
, False)
5215 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5216 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5217 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5219 mock_delete_floating_ip_by_id
.assert_called_once_with(
5220 f
"floating_ip:{floating_network_vim_id}",
5221 f
"{floating_network_vim_id}",
5224 self
.vimconn
.logger
.error
.assert_called_once_with(
5225 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
5228 @patch.object(vimconnector
, "_get_item_name_id")
5229 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5230 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5231 def test_delete_created_items_delete_fip_raises(
5233 mock_delete_floating_ip_by_id
,
5234 mock_delete_volumes_by_id_wth_cinder
,
5235 mock_get_item_name_id
,
5237 """Delete floating ip raises exception."""
5239 f
"floating_ip:{floating_network_vim_id}": True,
5240 f
"volume:{volume_id}": True,
5241 f
"port:{port_id}": None,
5243 mock_get_item_name_id
.side_effect
= [
5244 ("floating_ip", f
"{floating_network_vim_id}"),
5245 ("volume", f
"{volume_id}"),
5247 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5248 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
5249 "Connection failed."
5251 volumes_to_hold
= []
5253 result
= self
.vimconn
._delete
_created
_items
(
5254 created_items
, volumes_to_hold
, keep_waiting
5256 self
.assertEqual(result
, True)
5257 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5258 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5259 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5261 mock_delete_floating_ip_by_id
.assert_called_once_with(
5262 f
"floating_ip:{floating_network_vim_id}",
5263 f
"{floating_network_vim_id}",
5266 self
.vimconn
.logger
.error
.assert_called_once_with(
5267 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
5270 @patch.object(vimconnector
, "_get_item_name_id")
5271 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5272 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5273 def test_delete_created_items_get_item_name_raises(
5275 mock_delete_floating_ip_by_id
,
5276 mock_delete_volumes_by_id_wth_cinder
,
5277 mock_get_item_name_id
,
5279 """Get item, name raises exception."""
5282 f
"volume{volume_id}": True,
5283 f
"port:{port_id}": None,
5285 mock_get_item_name_id
.side_effect
= [
5286 TypeError("Invalid Type"),
5287 AttributeError("Invalid attribute"),
5289 volumes_to_hold
= []
5290 keep_waiting
= False
5291 result
= self
.vimconn
._delete
_created
_items
(
5292 created_items
, volumes_to_hold
, keep_waiting
5294 self
.assertEqual(result
, False)
5295 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5296 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5297 mock_delete_floating_ip_by_id
.assert_not_called()
5298 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
5299 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
5302 (f
"Error deleting volume{volume_id}: Invalid attribute",),
5305 @patch.object(vimconnector
, "_get_item_name_id")
5306 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5307 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5308 def test_delete_created_items_no_fip_wth_port(
5310 mock_delete_floating_ip_by_id
,
5311 mock_delete_volumes_by_id_wth_cinder
,
5312 mock_get_item_name_id
,
5314 """Created items has port, does not have floating ip."""
5316 f
"volume:{volume_id}": True,
5317 f
"port:{port_id}": True,
5319 mock_get_item_name_id
.side_effect
= [
5320 ("volume", f
"{volume_id}"),
5321 ("port", f
"{port_id}"),
5323 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5324 volumes_to_hold
= []
5325 keep_waiting
= False
5326 result
= self
.vimconn
._delete
_created
_items
(
5327 created_items
, volumes_to_hold
, keep_waiting
5329 self
.assertEqual(result
, False)
5330 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5331 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5332 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5334 mock_delete_floating_ip_by_id
.assert_not_called()
5335 self
.vimconn
.logger
.error
.assert_not_called()
5337 @patch.object(vimconnector
, "_get_item_name_id")
5338 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5339 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5340 def test_delete_created_items_no_volume(
5342 mock_delete_floating_ip_by_id
,
5343 mock_delete_volumes_by_id_wth_cinder
,
5344 mock_get_item_name_id
,
5346 """Created items does not have volume."""
5348 f
"floating_ip:{floating_network_vim_id}": True,
5349 f
"port:{port_id}": None,
5351 mock_get_item_name_id
.side_effect
= [
5352 ("floating_ip", f
"{floating_network_vim_id}")
5354 volumes_to_hold
= []
5355 keep_waiting
= False
5356 result
= self
.vimconn
._delete
_created
_items
(
5357 created_items
, volumes_to_hold
, keep_waiting
5359 self
.assertEqual(result
, False)
5360 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
5361 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5362 mock_delete_floating_ip_by_id
.assert_called_once_with(
5363 f
"floating_ip:{floating_network_vim_id}",
5364 f
"{floating_network_vim_id}",
5367 self
.vimconn
.logger
.error
.assert_not_called()
5369 @patch.object(vimconnector
, "_get_item_name_id")
5370 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5371 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5372 def test_delete_created_items_already_deleted(
5374 mock_delete_floating_ip_by_id
,
5375 mock_delete_volumes_by_id_wth_cinder
,
5376 mock_get_item_name_id
,
5378 """All created items are alerady deleted."""
5380 f
"floating_ip:{floating_network_vim_id}": None,
5381 f
"volume:{volume_id}": None,
5382 f
"port:{port_id}": None,
5384 volumes_to_hold
= []
5385 keep_waiting
= False
5386 result
= self
.vimconn
._delete
_created
_items
(
5387 created_items
, volumes_to_hold
, keep_waiting
5389 self
.assertEqual(result
, False)
5390 mock_get_item_name_id
.assert_not_called()
5391 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5392 mock_delete_floating_ip_by_id
.assert_not_called()
5393 self
.vimconn
.logger
.error
.assert_not_called()
5395 @patch("time.sleep")
5396 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5397 @patch.object(vimconnector
, "_format_exception")
5398 @patch.object(vimconnector
, "_reload_connection")
5399 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5400 @patch.object(vimconnector
, "_delete_created_items")
5401 def test_delete_vminstance_successfully(
5403 mock_delete_created_items
,
5404 mock_delete_vm_ports_attached_to_network
,
5405 mock_reload_connection
,
5406 mock_format_exception
,
5407 mock_extract_items_wth_keep_flag_from_created_items
,
5410 vm_id
= f
"{virtual_mac_id}"
5411 created_items
= deepcopy(created_items_all_true
)
5412 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5413 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5414 mock_delete_created_items
.return_value
= False
5415 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5416 mock_reload_connection
.assert_called_once()
5417 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5418 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5419 mock_delete_created_items
.assert_called_once_with(
5420 created_items
, volumes_to_hold
, False
5422 mock_sleep
.assert_not_called()
5423 mock_format_exception
.assert_not_called()
5424 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5428 @patch("time.sleep")
5429 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5430 @patch.object(vimconnector
, "_format_exception")
5431 @patch.object(vimconnector
, "_reload_connection")
5432 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5433 @patch.object(vimconnector
, "_delete_created_items")
5434 def test_delete_vminstance_created_items_has_keep_flag(
5436 mock_delete_created_items
,
5437 mock_delete_vm_ports_attached_to_network
,
5438 mock_reload_connection
,
5439 mock_format_exception
,
5440 mock_extract_items_wth_keep_flag_from_created_items
,
5443 """Created_items includes items which has keep flag."""
5444 vm_id
= f
"{virtual_mac_id}"
5445 initial_created_items
= {
5446 f
"port{port_id}": True,
5447 f
"floating_ip{floating_network_vim_id}": None,
5448 f
"volume{volume_id}keep": True,
5449 f
"volume{volume_id2}keep": True,
5452 f
"port{port_id}": True,
5453 f
"floating_ip{floating_network_vim_id}": None,
5455 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5456 volumes_to_hold
= []
5457 mock_delete_created_items
.return_value
= False
5458 self
.vimconn
.delete_vminstance(vm_id
, initial_created_items
, volumes_to_hold
)
5459 mock_reload_connection
.assert_called_once()
5460 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5461 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5462 mock_delete_created_items
.assert_called_once_with(
5463 created_items
, volumes_to_hold
, False
5465 mock_sleep
.assert_not_called()
5466 mock_format_exception
.assert_not_called()
5467 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5468 initial_created_items
5471 @patch("time.sleep")
5472 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5473 @patch.object(vimconnector
, "_format_exception")
5474 @patch.object(vimconnector
, "_reload_connection")
5475 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5476 @patch.object(vimconnector
, "_delete_created_items")
5477 def test_delete_vminstance_extract_items_wth_keep_raises(
5479 mock_delete_created_items
,
5480 mock_delete_vm_ports_attached_to_network
,
5481 mock_reload_connection
,
5482 mock_format_exception
,
5483 mock_extract_items_wth_keep_flag_from_created_items
,
5486 """extract_items_wth_keep_flag_from_created_items raises AttributeError."""
5487 vm_id
= f
"{virtual_mac_id}"
5488 initial_created_items
= {
5489 f
"port{port_id}": True,
5490 f
"floating_ip{floating_network_vim_id}": None,
5491 f
"volume{volume_id}keep": True,
5492 f
"volume{volume_id2}keep": True,
5495 mock_extract_items_wth_keep_flag_from_created_items
.side_effect
= AttributeError
5496 volumes_to_hold
= []
5497 mock_delete_created_items
.return_value
= False
5498 with self
.assertRaises(AttributeError):
5499 self
.vimconn
.delete_vminstance(
5500 vm_id
, initial_created_items
, volumes_to_hold
5502 mock_reload_connection
.assert_not_called()
5503 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5504 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5505 mock_delete_created_items
.assert_not_called()
5506 mock_sleep
.assert_not_called()
5507 mock_format_exception
.assert_not_called()
5508 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5509 initial_created_items
5512 @patch("time.sleep")
5513 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5514 @patch.object(vimconnector
, "_format_exception")
5515 @patch.object(vimconnector
, "_reload_connection")
5516 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5517 @patch.object(vimconnector
, "_delete_created_items")
5518 def test_delete_vminstance_delete_created_items_raises(
5520 mock_delete_created_items
,
5521 mock_delete_vm_ports_attached_to_network
,
5522 mock_reload_connection
,
5523 mock_format_exception
,
5524 mock_extract_items_wth_keep_flag_from_created_items
,
5527 """Delete creted items raises exception."""
5528 vm_id
= f
"{virtual_mac_id}"
5529 created_items
= deepcopy(created_items_all_true
)
5530 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5531 mock_sleep
= MagicMock()
5532 volumes_to_hold
= []
5533 err
= ConnectionError("ClientException occured.")
5534 mock_delete_created_items
.side_effect
= err
5535 with self
.assertRaises(ConnectionError
) as err
:
5536 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5537 self
.assertEqual(str(err
), "ClientException occured.")
5538 mock_reload_connection
.assert_called_once()
5539 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5540 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5541 mock_delete_created_items
.assert_called_once()
5542 mock_sleep
.assert_not_called()
5543 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5547 @patch("time.sleep")
5548 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5549 @patch.object(vimconnector
, "_format_exception")
5550 @patch.object(vimconnector
, "_reload_connection")
5551 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5552 @patch.object(vimconnector
, "_delete_created_items")
5553 def test_delete_vminstance_delete_vm_ports_raises(
5555 mock_delete_created_items
,
5556 mock_delete_vm_ports_attached_to_network
,
5557 mock_reload_connection
,
5558 mock_format_exception
,
5559 mock_extract_items_wth_keep_flag_from_created_items
,
5562 """Delete vm ports raises exception."""
5563 vm_id
= f
"{virtual_mac_id}"
5564 created_items
= deepcopy(created_items_all_true
)
5565 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5566 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5567 err
= ConnectionError("ClientException occured.")
5568 mock_delete_vm_ports_attached_to_network
.side_effect
= err
5569 mock_delete_created_items
.side_effect
= err
5570 with self
.assertRaises(ConnectionError
) as err
:
5571 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5572 self
.assertEqual(str(err
), "ClientException occured.")
5573 mock_reload_connection
.assert_called_once()
5574 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5575 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5576 mock_delete_created_items
.assert_not_called()
5577 mock_sleep
.assert_not_called()
5578 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5582 @patch("time.sleep")
5583 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5584 @patch.object(vimconnector
, "_format_exception")
5585 @patch.object(vimconnector
, "_reload_connection")
5586 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5587 @patch.object(vimconnector
, "_delete_created_items")
5588 def test_delete_vminstance_nova_server_delete_raises(
5590 mock_delete_created_items
,
5591 mock_delete_vm_ports_attached_to_network
,
5592 mock_reload_connection
,
5593 mock_format_exception
,
5594 mock_extract_items_wth_keep_flag_from_created_items
,
5597 """Nova server delete raises exception."""
5598 vm_id
= f
"{virtual_mac_id}"
5599 created_items
= deepcopy(created_items_all_true
)
5600 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5601 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5602 err
= VimConnConnectionException("ClientException occured.")
5603 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
5604 mock_delete_created_items
.side_effect
= err
5605 with self
.assertRaises(VimConnConnectionException
) as err
:
5606 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5607 self
.assertEqual(str(err
), "ClientException occured.")
5608 mock_reload_connection
.assert_called_once()
5609 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5610 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5611 mock_delete_created_items
.assert_not_called()
5612 mock_sleep
.assert_not_called()
5613 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5617 @patch("time.sleep")
5618 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5619 @patch.object(vimconnector
, "_format_exception")
5620 @patch.object(vimconnector
, "_reload_connection")
5621 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5622 @patch.object(vimconnector
, "_delete_created_items")
5623 def test_delete_vminstance_reload_connection_raises(
5625 mock_delete_created_items
,
5626 mock_delete_vm_ports_attached_to_network
,
5627 mock_reload_connection
,
5628 mock_format_exception
,
5629 mock_extract_items_wth_keep_flag_from_created_items
,
5632 """Reload connection raises exception."""
5633 vm_id
= f
"{virtual_mac_id}"
5634 created_items
= deepcopy(created_items_all_true
)
5635 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5636 mock_sleep
= MagicMock()
5637 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5638 err
= ConnectionError("ClientException occured.")
5639 mock_delete_created_items
.return_value
= False
5640 mock_reload_connection
.side_effect
= err
5641 with self
.assertRaises(ConnectionError
) as err
:
5642 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5643 self
.assertEqual(str(err
), "ClientException occured.")
5644 mock_reload_connection
.assert_called_once()
5645 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5646 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5647 mock_delete_created_items
.assert_not_called()
5648 mock_sleep
.assert_not_called()
5649 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5653 @patch("time.sleep")
5654 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5655 @patch.object(vimconnector
, "_format_exception")
5656 @patch.object(vimconnector
, "_reload_connection")
5657 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5658 @patch.object(vimconnector
, "_delete_created_items")
5659 def test_delete_vminstance_created_item_vol_to_hold_are_none(
5661 mock_delete_created_items
,
5662 mock_delete_vm_ports_attached_to_network
,
5663 mock_reload_connection
,
5664 mock_format_exception
,
5665 mock_extract_items_wth_keep_flag_from_created_items
,
5668 """created_items and volumes_to_hold are None."""
5669 vm_id
= f
"{virtual_mac_id}"
5670 created_items
= None
5671 volumes_to_hold
= None
5672 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= {}
5673 mock_delete_created_items
.return_value
= False
5674 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5675 mock_reload_connection
.assert_called_once()
5676 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5677 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5678 mock_delete_created_items
.assert_called_once_with({}, [], False)
5679 mock_sleep
.assert_not_called()
5680 mock_format_exception
.assert_not_called()
5681 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with({})
5683 @patch("time.sleep")
5684 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5685 @patch.object(vimconnector
, "_format_exception")
5686 @patch.object(vimconnector
, "_reload_connection")
5687 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5688 @patch.object(vimconnector
, "_delete_created_items")
5689 def test_delete_vminstance_vm_id_is_none(
5691 mock_delete_created_items
,
5692 mock_delete_vm_ports_attached_to_network
,
5693 mock_reload_connection
,
5694 mock_format_exception
,
5695 mock_extract_items_wth_keep_flag_from_created_items
,
5698 """vm_id is None."""
5700 created_items
= deepcopy(created_items_all_true
)
5701 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5702 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5703 mock_delete_created_items
.side_effect
= [True, True, False]
5704 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5705 mock_reload_connection
.assert_called_once()
5706 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5707 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5708 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
5709 self
.assertEqual(mock_sleep
.call_count
, 2)
5710 mock_format_exception
.assert_not_called()
5711 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5715 @patch("time.sleep")
5716 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5717 @patch.object(vimconnector
, "_format_exception")
5718 @patch.object(vimconnector
, "_reload_connection")
5719 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5720 @patch.object(vimconnector
, "_delete_created_items")
5721 def test_delete_vminstance_delete_created_items_return_true(
5723 mock_delete_created_items
,
5724 mock_delete_vm_ports_attached_to_network
,
5725 mock_reload_connection
,
5726 mock_format_exception
,
5727 mock_extract_items_wth_keep_flag_from_created_items
,
5730 """Delete created items always return True."""
5732 created_items
= deepcopy(created_items_all_true
)
5733 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5734 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5735 mock_delete_created_items
.side_effect
= [True] * 1800
5736 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5737 mock_reload_connection
.assert_called_once()
5738 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5739 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5740 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
5741 self
.assertEqual(mock_sleep
.call_count
, 1800)
5742 mock_format_exception
.assert_not_called()
5743 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5747 def test_remove_keep_tag_from_persistent_volumes_keep_flag_exists(self
):
5748 """Keep flag exists in created items."""
5750 f
"port:{port_id}": True,
5751 f
"floating_ip:{floating_network_vim_id}": True,
5752 f
"volume:{volume_id}:keep": True,
5753 f
"volume:{volume_id2}:keep": True,
5756 f
"port:{port_id}": True,
5757 f
"floating_ip:{floating_network_vim_id}": True,
5758 f
"volume:{volume_id}": True,
5759 f
"volume:{volume_id2}": True,
5761 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
5762 self
.assertDictEqual(result
, expected_result
)
5764 def test_remove_keep_tag_from_persistent_volumes_without_keep_flag(self
):
5765 """Keep flag does not exist in created items."""
5767 f
"port:{port_id}": True,
5768 f
"floating_ip:{floating_network_vim_id}": True,
5769 f
"volume:{volume_id}": True,
5770 f
"volume:{volume_id2}": True,
5772 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
5773 self
.assertDictEqual(result
, created_items
)
5775 def test_update_block_device_mapping_empty_volume(self
):
5778 block_device_mapping
= {}
5779 base_disk_index
= 100
5782 with self
.assertRaises(VimConnException
) as err
:
5783 self
.vimconn
.update_block_device_mapping(
5784 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
5786 self
.assertEqual(str(err
), "Volume is empty.")
5787 self
.assertEqual(block_device_mapping
, {})
5788 self
.assertEqual(created_items
, {})
5790 def test_update_block_device_mapping_invalid_volume(self
):
5793 block_device_mapping
= {}
5794 base_disk_index
= 100
5797 with self
.assertRaises(VimConnException
) as err
:
5798 self
.vimconn
.update_block_device_mapping(
5799 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
5802 str(err
), "Created volume is not valid, does not have id attribute."
5804 self
.assertEqual(block_device_mapping
, {})
5805 self
.assertEqual(created_items
, {})
5807 def test_update_block_device_mapping(self
):
5809 volume
= MagicMock(autospec
=True)
5810 volume
.id = volume_id
5811 block_device_mapping
= {}
5812 base_disk_index
= 100
5815 self
.vimconn
.update_block_device_mapping(
5816 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
5819 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
5822 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a": True}
5825 def test_update_block_device_mapping_with_keep_flag(self
):
5827 volume
= MagicMock(autospec
=True)
5828 volume
.id = volume_id
5829 block_device_mapping
= {}
5830 base_disk_index
= 100
5831 disk
= {"size": 10, "keep": True}
5833 self
.vimconn
.update_block_device_mapping(
5834 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
5837 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
5840 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a:keep": True}
5843 def test_extract_items_with_keep_flag_item_has_keep_flag(self
):
5844 created_items
= deepcopy(created_items_all_true
)
5845 created_items
[f
"volume:{volume_id2}:keep"] = True
5846 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5849 self
.assertEqual(result
, deepcopy(created_items_all_true
))
5851 def test_extract_items_with_keep_flag_no_item_wth_keep_flag(self
):
5852 created_items
= deepcopy(created_items_all_true
)
5853 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5856 self
.assertEqual(result
, deepcopy(created_items_all_true
))
5858 def test_extract_items_with_keep_flag_all_items_are_already_deleted(self
):
5860 f
"port:{port_id}": None,
5861 f
"floating_ip:{floating_network_vim_id}": None,
5862 f
"volume:{volume_id}:keep": None,
5863 f
"volume:{volume_id2}:keep": None,
5866 f
"port:{port_id}": None,
5867 f
"floating_ip:{floating_network_vim_id}": None,
5869 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5872 self
.assertEqual(result
, expected_result
)
5874 def test_extract_items_with_keep_flag_without_semicolon(self
):
5876 f
"port{port_id}": True,
5877 f
"floating_ip{floating_network_vim_id}": None,
5878 f
"volume{volume_id}keep": True,
5879 f
"volume{volume_id2}keep": True,
5881 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5884 self
.assertEqual(result
, {})
5886 def test_extract_items_with_keep_flag_invalid_type_created_items(self
):
5887 created_items
= [{f
"port{port_id}": True}, {f
"volume{volume_id2}keep": True}]
5888 with self
.assertRaises(AttributeError):
5889 self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(created_items
)
5892 if __name__
== "__main__":