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"}
3310 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3311 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3312 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3313 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3316 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3317 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3318 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3319 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3322 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
3323 "floatingips": floating_ips
3325 mock_find_floating_ip
.return_value
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3326 expected_result
= "508b73-o9cc-5a6a-a270-72cc4811bd8"
3328 result
= self
.vimconn
._get
_free
_floating
_ip
(
3329 self
.server
, floating_network
, created_items
3331 self
.assertEqual(result
, expected_result
)
3332 mock_shuffle
.assert_called_once_with(floating_ips
)
3333 mock_find_floating_ip
.assert_called_once_with(
3334 self
.server
, floating_ips
, floating_network
, created_items
3337 @patch("random.shuffle")
3338 @patch.object(vimconnector
, "_find_floating_ip")
3339 def test_get_free_floating_ip_list_floating_ip_exception(
3340 self
, mock_find_floating_ip
, mock_shuffle
3342 """Neutron list floating IPs raises exception."""
3343 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3345 self
.vimconn
.neutron
= CopyingMock()
3346 self
.vimconn
.neutron
.list_floatingips
.side_effect
= Exception(
3347 "Floating ips could not be listed."
3349 with self
.assertRaises(Exception) as err
:
3350 result
= self
.vimconn
._get
_free
_floating
_ip
(
3351 self
.server
, floating_network
, created_items
3353 self
.assertEqual(result
, None)
3354 self
.assertEqual(str(err
.exception
), "Floating ips could not be listed.")
3355 mock_shuffle
.assert_not_called()
3356 mock_find_floating_ip
.assert_not_called()
3358 @patch("random.shuffle")
3359 @patch.object(vimconnector
, "_find_floating_ip")
3360 def test_get_free_floating_ip_find_floating_ip_exception(
3361 self
, mock_find_floating_ip
, mock_shuffle
3363 """_find_floating_ip method raises exception."""
3364 floating_network
= {"floating_ip": "308b73-t9cc-1a6a-a270-12cc4811bd4a"}
3368 "port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3369 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3370 "id": "508b73-o9cc-5a6a-a270-72cc4811bd8",
3371 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3374 "port_id": "508b73-r9cc-5a6a-5270-o2cc4811bd4a",
3375 "floating_network_id": "308b73-t9cc-1a6a-a270-12cc4811bd4a",
3376 "id": "208b73-o9cc-5a6a-a270-52cc4811bd8",
3377 "tenant_id": "208b73-e9cc-5a6a-t270-82cc4811bd4a",
3380 self
.vimconn
.neutron
= CopyingMock()
3381 self
.vimconn
.neutron
.list_floatingips
.return_value
= {
3382 "floatingips": floating_ips
3384 mock_find_floating_ip
.side_effect
= Exception(
3385 "Free floating ip could not be found."
3388 with self
.assertRaises(Exception) as err
:
3389 result
= self
.vimconn
._get
_free
_floating
_ip
(
3390 self
.server
, floating_network
, created_items
3392 self
.assertEqual(result
, None)
3393 self
.assertEqual(str(err
.exception
), "Free floating ip could not be found.")
3394 mock_shuffle
.assert_called_once_with(floating_ips
)
3395 mock_find_floating_ip
.assert_called_once_with(
3396 self
.server
, floating_ips
, floating_network
, created_items
3399 @patch.object(vimconnector
, "_create_floating_ip")
3400 @patch.object(vimconnector
, "_get_free_floating_ip")
3401 @patch.object(vimconnector
, "_assign_floating_ip")
3402 def test_prepare_external_network_for_vm_instance(
3404 mock_assign_floating_ip
,
3405 mock_get_free_floating_ip
,
3406 mock_create_floating_ip
,
3408 """Prepare external network successfully."""
3409 external_network
= [
3411 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3412 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3416 vm_start_time
= time_return_value
3417 mock_get_free_floating_ip
.side_effect
= ["y08b73-o9cc-1a6a-a270-12cc4811bd4u"]
3418 mock_assign_floating_ip
.return_value
= {
3419 "floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}
3421 self
.vimconn
.neutron
= CopyingMock()
3422 self
.vimconn
.nova
= CopyingMock()
3423 self
.vimconn
.neutron
.show_floatingip
.return_value
= {
3424 "floatingip": {"port_id": ""}
3427 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3428 external_network
, self
.server
, created_items
, vm_start_time
3431 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3432 mock_get_free_floating_ip
.assert_called_once_with(
3435 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3436 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3440 self
.vimconn
.neutron
.show_floatingip
.assert_called_once_with(
3441 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3443 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3444 mock_create_floating_ip
.assert_not_called()
3445 mock_assign_floating_ip
.assert_called_once_with(
3446 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3448 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3449 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3454 @patch("time.sleep")
3455 @patch.object(vimconnector
, "_create_floating_ip")
3456 @patch.object(vimconnector
, "_get_free_floating_ip")
3457 @patch.object(vimconnector
, "_assign_floating_ip")
3458 def test_prepare_external_network_for_vm_instance_no_free_floating_ip(
3460 mock_assign_floating_ip
,
3461 mock_get_free_floating_ip
,
3462 mock_create_floating_ip
,
3466 """There is not any free floating ip."""
3467 floating_network
= {
3468 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3469 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3471 external_network
= [floating_network
]
3474 vm_start_time
= time_return_value
3475 mock_get_free_floating_ip
.return_value
= None
3476 mock_assign_floating_ip
.return_value
= {}
3477 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3478 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3480 with self
.assertRaises(KeyError):
3481 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3482 external_network
, self
.server
, created_items
, vm_start_time
3485 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3486 mock_get_free_floating_ip
.assert_called_with(
3489 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3490 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3494 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(None)
3495 mock_sleep
.assert_not_called()
3496 mock_time
.assert_not_called()
3497 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
3498 mock_create_floating_ip
.assert_called_with(
3499 floating_network
, self
.server
, created_items
3501 self
.assertEqual(mock_create_floating_ip
.call_count
, 4)
3502 mock_assign_floating_ip
.assert_not_called()
3503 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3506 @patch("time.sleep")
3507 @patch.object(vimconnector
, "_create_floating_ip")
3508 @patch.object(vimconnector
, "_get_free_floating_ip")
3509 @patch.object(vimconnector
, "_assign_floating_ip")
3510 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_false(
3512 mock_assign_floating_ip
,
3513 mock_get_free_floating_ip
,
3514 mock_create_floating_ip
,
3518 """There is not any free floating ip, create_floating ip method raise exception
3519 exit_on_floating_ip_error set to False."""
3520 floating_network
= {
3521 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3522 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3523 "exit_on_floating_ip_error": False,
3525 external_network
= [floating_network
]
3528 vm_start_time
= time_return_value
3529 mock_get_free_floating_ip
.return_value
= None
3530 mock_assign_floating_ip
.return_value
= {}
3531 mock_create_floating_ip
.side_effect
= VimConnException(
3532 "Can not create floating ip."
3534 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3535 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3537 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3538 external_network
, self
.server
, created_items
, vm_start_time
3540 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3541 mock_get_free_floating_ip
.assert_called_with(
3544 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3545 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3546 "exit_on_floating_ip_error": False,
3550 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3551 mock_sleep
.assert_not_called()
3552 mock_time
.assert_not_called()
3553 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3554 mock_create_floating_ip
.assert_called_with(
3555 floating_network
, self
.server
, created_items
3557 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
3558 mock_assign_floating_ip
.assert_not_called()
3561 @patch("time.sleep")
3562 @patch.object(vimconnector
, "_create_floating_ip")
3563 @patch.object(vimconnector
, "_get_free_floating_ip")
3564 @patch.object(vimconnector
, "_assign_floating_ip")
3565 def test_prepare_external_network_for_vm_instance_no_free_fip_can_not_create_fip_exit_on_error_true(
3567 mock_assign_floating_ip
,
3568 mock_get_free_floating_ip
,
3569 mock_create_floating_ip
,
3573 """There is not any free floating ip, create_floating ip method raise exception
3574 exit_on_floating_ip_error set to False."""
3575 floating_network
= {
3576 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3577 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3578 "exit_on_floating_ip_error": True,
3580 external_network
= [floating_network
]
3583 vm_start_time
= time_return_value
3584 mock_get_free_floating_ip
.return_value
= None
3585 mock_assign_floating_ip
.return_value
= {}
3586 mock_create_floating_ip
.side_effect
= VimConnException(
3587 "Can not create floating ip."
3589 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3590 self
.vimconn
.neutron
.show_floatingip
.return_value
= {}
3591 with self
.assertRaises(VimConnException
):
3592 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3593 external_network
, self
.server
, created_items
, vm_start_time
3595 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 1)
3596 mock_get_free_floating_ip
.assert_called_with(
3599 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3600 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3601 "exit_on_floating_ip_error": True,
3605 self
.vimconn
.neutron
.show_floatingip
.assert_not_called()
3606 mock_sleep
.assert_not_called()
3607 mock_time
.assert_not_called()
3608 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3609 mock_create_floating_ip
.assert_called_with(
3610 floating_network
, self
.server
, created_items
3612 self
.assertEqual(mock_create_floating_ip
.call_count
, 1)
3613 mock_assign_floating_ip
.assert_not_called()
3615 @patch.object(vimconnector
, "_create_floating_ip")
3616 @patch.object(vimconnector
, "_get_free_floating_ip")
3617 @patch.object(vimconnector
, "_assign_floating_ip")
3618 def test_prepare_external_network_for_vm_instance_fip_has_port_id(
3620 mock_assign_floating_ip
,
3621 mock_get_free_floating_ip
,
3622 mock_create_floating_ip
,
3624 """Neutron show floating ip return the fip with port_id and floating network vim_id
3625 is different from port_id."""
3626 floating_network
= {
3627 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3628 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3630 external_network
= [floating_network
]
3633 mock_get_free_floating_ip
.side_effect
= [
3634 "t08b73-o9cc-1a6a-a270-12cc4811bd4u",
3635 "r08b73-o9cc-1a6a-a270-12cc4811bd4u",
3636 "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3638 mock_assign_floating_ip
.side_effect
= [
3639 {"floatingip": {"port_id": "k08b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3640 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3642 self
.vimconn
.neutron
= CopyingMock()
3643 self
.vimconn
.nova
= CopyingMock()
3644 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3645 {"floatingip": {"port_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a"}},
3646 {"floatingip": {"port_id": ""}},
3647 {"floatingip": {"port_id": ""}},
3649 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3650 external_network
, self
.server
, created_items
, vm_start_time
3652 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3653 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3655 _call_mock_get_free_floating_ip
[0][0],
3663 _call_mock_get_free_floating_ip
[1][0],
3671 _call_mock_get_free_floating_ip
[2][0],
3678 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3679 self
.vimconn
.nova
.servers
.get
.assert_not_called()
3680 mock_create_floating_ip
.assert_not_called()
3681 self
.assertEqual(mock_assign_floating_ip
.call_count
, 2)
3682 _call_mock_assign_floating_ip
= mock_assign_floating_ip
.call_args_list
3684 _call_mock_assign_floating_ip
[0][0],
3685 ("r08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
3688 _call_mock_assign_floating_ip
[1][0],
3689 ("y08b73-o9cc-1a6a-a270-12cc4811bd4u", floating_network
),
3693 @patch("time.sleep")
3694 @patch.object(vimconnector
, "_create_floating_ip")
3695 @patch.object(vimconnector
, "_get_free_floating_ip")
3696 @patch.object(vimconnector
, "_assign_floating_ip")
3697 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_error(
3699 mock_assign_floating_ip
,
3700 mock_get_free_floating_ip
,
3701 mock_create_floating_ip
,
3705 """Neutron show floating ip gives exception, exit_on_floating_ip_error set to True,
3706 VM status is in error."""
3707 floating_network
= {
3708 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3709 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3710 "exit_on_floating_ip_error": True,
3712 external_network
= [floating_network
]
3714 vm_start_time
= time_return_value
3716 mock_time
.side_effect
= [156570150, 156570800, 156571200]
3718 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3719 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3720 Exception("Floating ip could not be shown.")
3722 with self
.assertRaises(Exception) as err
:
3723 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3724 external_network
, self
.server
, created_items
, vm_start_time
3728 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3731 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3732 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3734 _call_mock_get_free_floating_ip
[0][0],
3742 _call_mock_get_free_floating_ip
[1][0],
3750 _call_mock_get_free_floating_ip
[2][0],
3758 _call_mock_get_free_floating_ip
[3][0],
3766 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3767 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3768 mock_create_floating_ip
.assert_not_called()
3769 mock_assign_floating_ip
.assert_not_called()
3770 mock_time
.assert_not_called()
3771 mock_sleep
.assert_not_called()
3774 @patch("time.sleep")
3775 @patch.object(vimconnector
, "_create_floating_ip")
3776 @patch.object(vimconnector
, "_get_free_floating_ip")
3777 @patch.object(vimconnector
, "_assign_floating_ip")
3778 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_vm_status_in_active(
3780 mock_assign_floating_ip
,
3781 mock_get_free_floating_ip
,
3782 mock_create_floating_ip
,
3786 """Neutron show floating ip gives exception, exit_on_floating_ip_error is set to False,
3787 VM status is in active."""
3788 floating_network
= {
3789 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3790 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3791 "exit_on_floating_ip_error": False,
3793 external_network
= [floating_network
]
3795 vm_start_time
= time_return_value
3797 mock_time
.side_effect
= [156570150, 156570800, 156571200]
3799 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ACTIVE"
3800 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3801 Exception("Floating ip could not be shown.")
3804 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3805 external_network
, self
.server
, created_items
, vm_start_time
3807 # self.assertEqual(str(err.exception), "Cannot create floating_ip")
3809 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3810 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3812 _call_mock_get_free_floating_ip
[0][0],
3820 _call_mock_get_free_floating_ip
[1][0],
3828 _call_mock_get_free_floating_ip
[2][0],
3836 _call_mock_get_free_floating_ip
[3][0],
3844 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
3845 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3846 mock_create_floating_ip
.assert_not_called()
3847 mock_assign_floating_ip
.assert_not_called()
3848 mock_time
.assert_not_called()
3849 mock_sleep
.assert_not_called()
3852 @patch("time.sleep")
3853 @patch.object(vimconnector
, "_create_floating_ip")
3854 @patch.object(vimconnector
, "_get_free_floating_ip")
3855 @patch.object(vimconnector
, "_assign_floating_ip")
3856 def test_prepare_external_network_for_vm_instance_neutron_show_fip_exception_exit_on_error(
3858 mock_assign_floating_ip
,
3859 mock_get_free_floating_ip
,
3860 mock_create_floating_ip
,
3864 """Neutron show floating ip gives exception, but exit_on_floating_ip_error is set to True.
3865 VM status is not ACTIVE or ERROR, server timeout happened."""
3866 floating_network
= {
3867 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3868 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3869 "exit_on_floating_ip_error": True,
3871 external_network
= [floating_network
]
3873 vm_start_time
= time_return_value
3874 mock_get_free_floating_ip
.side_effect
= None
3875 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3876 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "OTHER"
3877 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3878 Exception("Floating ip could not be shown.")
3881 with self
.assertRaises(VimConnException
) as err
:
3882 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3883 external_network
, self
.server
, created_items
, vm_start_time
3887 "Cannot create floating_ip: Exception Floating ip could not be shown.",
3890 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 3)
3891 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3893 _call_mock_get_free_floating_ip
[0][0],
3901 _call_mock_get_free_floating_ip
[1][0],
3909 _call_mock_get_free_floating_ip
[2][0],
3917 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 3)
3918 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
3919 mock_create_floating_ip
.assert_not_called()
3920 mock_assign_floating_ip
.assert_not_called()
3921 self
.assertEqual(mock_time
.call_count
, 3)
3922 self
.assertEqual(mock_sleep
.call_count
, 2)
3925 @patch("time.sleep")
3926 @patch.object(vimconnector
, "_create_floating_ip")
3927 @patch.object(vimconnector
, "_get_free_floating_ip")
3928 @patch.object(vimconnector
, "_assign_floating_ip")
3929 def test_prepare_external_network_for_vm_instance_assign_floating_ip_exception_exit_on_error(
3931 mock_assign_floating_ip
,
3932 mock_get_free_floating_ip
,
3933 mock_create_floating_ip
,
3937 """Assign floating ip method gives exception, exit_on_floating_ip_error is set to True.
3938 VM status is in ERROR."""
3939 floating_network
= {
3940 "floating_ip": "y08b73-o9cc-1a6a-a270-12cc4811bd4u",
3941 "vim_id": "608b73-r9cc-5a6a-a270-82cc4811bd4a",
3942 "exit_on_floating_ip_error": True,
3944 external_network
= [floating_network
]
3946 vm_start_time
= time_return_value
3948 mock_get_free_floating_ip
.side_effect
= [
3949 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
3952 mock_time
.side_effect
= [156571790, 156571795, 156571800, 156571805]
3954 mock_assign_floating_ip
.side_effect
= [
3955 Exception("Floating ip could not be assigned.")
3958 self
.vimconn
.nova
.servers
.get
.return_value
.status
= "ERROR"
3959 self
.vimconn
.neutron
.show_floatingip
.side_effect
= [
3960 {"floatingip": {"port_id": ""}}
3963 with self
.assertRaises(VimConnException
) as err
:
3964 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
3965 external_network
, self
.server
, created_items
, vm_start_time
3969 "Cannot create floating_ip: Exception Floating ip could not be assigned.",
3972 self
.assertEqual(mock_get_free_floating_ip
.call_count
, 4)
3973 _call_mock_get_free_floating_ip
= mock_get_free_floating_ip
.call_args_list
3975 _call_mock_get_free_floating_ip
[0][0],
3983 _call_mock_get_free_floating_ip
[1][0],
3991 _call_mock_get_free_floating_ip
[2][0],
3999 self
.assertEqual(self
.vimconn
.neutron
.show_floatingip
.call_count
, 4)
4000 self
.vimconn
.neutron
.show_floatingip
.assert_called_with(
4001 "y08b73-o9cc-1a6a-a270-12cc4811bd4u"
4003 self
.assertEqual(self
.vimconn
.nova
.servers
.get
.call_count
, 4)
4004 self
.vimconn
.nova
.servers
.get
.assert_called_with(self
.server
.id)
4005 mock_time
.assert_not_called()
4006 mock_sleep
.assert_not_called()
4007 mock_create_floating_ip
.assert_not_called()
4010 @patch("time.sleep")
4011 @patch.object(vimconnector
, "_create_floating_ip")
4012 @patch.object(vimconnector
, "_get_free_floating_ip")
4013 @patch.object(vimconnector
, "_assign_floating_ip")
4014 def test_prepare_external_network_for_vm_instance_empty_external_network_list(
4016 mock_assign_floating_ip
,
4017 mock_get_free_floating_ip
,
4018 mock_create_floating_ip
,
4022 """External network list is empty."""
4023 external_network
= []
4025 vm_start_time
= time_return_value
4027 self
.vimconn
._prepare
_external
_network
_for
_vminstance
(
4028 external_network
, self
.server
, created_items
, vm_start_time
4030 mock_create_floating_ip
.assert_not_called()
4031 mock_time
.assert_not_called()
4032 mock_sleep
.assert_not_called()
4033 mock_assign_floating_ip
.assert_not_called()
4034 mock_get_free_floating_ip
.assert_not_called()
4035 self
.vimconn
.neutron
.show
.show_floatingip
.assert_not_called()
4036 self
.vimconn
.nova
.servers
.get
.assert_not_called()
4038 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4039 def test_update_port_security_for_vm_instance(self
, mock_wait_for_vm
):
4040 """no_secured_ports has port and the port has allow-address-pairs."""
4041 no_secured_ports
= [(port2_id
, "allow-address-pairs")]
4043 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
4045 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
4047 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
4049 {"port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}},
4052 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4053 def test_update_port_security_for_vm_instance_no_allowed_address_pairs(
4054 self
, mock_wait_for_vm
4056 """no_secured_ports has port and the port does not have allow-address-pairs."""
4057 no_secured_ports
= [(port2_id
, "something")]
4059 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
4061 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
4063 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
4065 {"port": {"port_security_enabled": False, "security_groups": None}},
4068 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4069 def test_update_port_security_for_vm_instance_wait_for_vm_raise_exception(
4070 self
, mock_wait_for_vm
4072 """__wait_for_vm raises timeout exception."""
4073 no_secured_ports
= [(port2_id
, "something")]
4075 mock_wait_for_vm
.side_effect
= VimConnException("Timeout waiting for instance.")
4077 with self
.assertRaises(VimConnException
) as err
:
4078 self
.vimconn
._update
_port
_security
_for
_vminstance
(
4079 no_secured_ports
, self
.server
4081 self
.assertEqual(str(err
.exception
), "Timeout waiting for instance.")
4083 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
4085 self
.vimconn
.neutron
.update_port
.assert_not_called()
4087 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4088 def test_update_port_security_for_vm_instance_neutron_update_port_raise_exception(
4089 self
, mock_wait_for_vm
4091 """neutron_update_port method raises exception."""
4092 no_secured_ports
= [(port2_id
, "something")]
4094 self
.vimconn
.neutron
.update_port
.side_effect
= Exception(
4095 "Port security could not be updated."
4098 with self
.assertRaises(VimConnException
) as err
:
4099 self
.vimconn
._update
_port
_security
_for
_vminstance
(
4100 no_secured_ports
, self
.server
4104 "It was not possible to disable port security for port 17472685-f67f-49fd-8722-eabb7692fc22",
4106 mock_wait_for_vm
.assert_called_once_with(self
.server
.id, "ACTIVE")
4108 self
.vimconn
.neutron
.update_port
.assert_called_once_with(
4110 {"port": {"port_security_enabled": False, "security_groups": None}},
4113 @patch.object(vimconnector
, "_vimconnector__wait_for_vm")
4114 def test_update_port_security_for_vm_instance_empty_port_list(
4115 self
, mock_wait_for_vm
4117 """no_secured_ports list does not have any ports."""
4118 no_secured_ports
= []
4120 self
.vimconn
._update
_port
_security
_for
_vminstance
(no_secured_ports
, self
.server
)
4122 mock_wait_for_vm
.assert_not_called()
4124 self
.vimconn
.neutron
.update_port
.assert_not_called()
4127 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4128 @patch.object(vimconnector
, "_reload_connection")
4129 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4130 @patch.object(vimconnector
, "_create_user_data")
4131 @patch.object(vimconnector
, "_get_vm_availability_zone")
4132 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4133 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4134 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4135 @patch.object(vimconnector
, "delete_vminstance")
4136 @patch.object(vimconnector
, "_format_exception")
4137 def test_new_vm_instance(
4139 mock_format_exception
,
4140 mock_delete_vm_instance
,
4141 mock_prepare_external_network
,
4142 mock_update_port_security
,
4143 mock_prepare_disk_for_vm_instance
,
4144 mock_get_vm_availability_zone
,
4145 mock_create_user_data
,
4146 mock_prepare_network_for_vm_instance
,
4147 mock_reload_connection
,
4148 mock_remove_keep_flag_from_persistent_volumes
,
4151 """New VM instance creation is successful."""
4153 mock_create_user_data
.return_value
= True, "userdata"
4155 mock_get_vm_availability_zone
.return_value
= "nova"
4157 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4159 mock_time
.return_value
= time_return_value
4161 expected_result
= self
.server
.id, {}
4163 result
= self
.vimconn
.new_vminstance(
4169 affinity_group_list
,
4173 availability_zone_index
,
4174 availability_zone_list
,
4176 self
.assertEqual(result
, expected_result
)
4178 mock_reload_connection
.assert_called_once()
4179 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4184 external_network
=[],
4185 no_secured_ports
=[],
4187 mock_create_user_data
.assert_called_once_with(cloud_config
)
4188 mock_get_vm_availability_zone
.assert_called_once_with(
4189 availability_zone_index
, availability_zone_list
4191 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4193 existing_vim_volumes
=[],
4196 block_device_mapping
={},
4197 disk_list
=disk_list2
,
4199 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4204 security_groups
="default",
4205 availability_zone
="nova",
4206 key_name
="my_keypair",
4207 userdata
="userdata",
4209 block_device_mapping
={},
4212 mock_time
.assert_called_once()
4213 mock_update_port_security
.assert_called_once_with([], self
.server
)
4214 mock_prepare_external_network
.assert_called_once_with(
4215 external_network
=[],
4218 vm_start_time
=time_return_value
,
4220 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
4221 mock_delete_vm_instance
.assert_not_called()
4222 mock_format_exception
.assert_not_called()
4225 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4226 @patch.object(vimconnector
, "_reload_connection")
4227 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4228 @patch.object(vimconnector
, "_create_user_data")
4229 @patch.object(vimconnector
, "_get_vm_availability_zone")
4230 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4231 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4232 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4233 @patch.object(vimconnector
, "delete_vminstance")
4234 @patch.object(vimconnector
, "_format_exception")
4235 def test_new_vm_instance_create_user_data_fails(
4237 mock_format_exception
,
4238 mock_delete_vm_instance
,
4239 mock_prepare_external_network
,
4240 mock_update_port_security
,
4241 mock_prepare_disk_for_vm_instance
,
4242 mock_get_vm_availability_zone
,
4243 mock_create_user_data
,
4244 mock_prepare_network_for_vm_instance
,
4245 mock_reload_connection
,
4246 mock_remove_keep_flag_from_persistent_volumes
,
4249 """New VM instance creation failed because of user data creation failure."""
4251 mock_create_user_data
.side_effect
= Exception(
4252 "User data could not be retrieved."
4255 mock_get_vm_availability_zone
.return_value
= "nova"
4257 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
4259 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4261 mock_time
.return_value
= time_return_value
4263 self
.vimconn
.new_vminstance(
4269 affinity_group_list
,
4273 availability_zone_index
,
4274 availability_zone_list
,
4277 mock_reload_connection
.assert_called_once()
4278 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4283 external_network
=[],
4284 no_secured_ports
=[],
4286 mock_create_user_data
.assert_called_once_with(cloud_config
)
4287 mock_get_vm_availability_zone
.assert_not_called()
4288 mock_prepare_disk_for_vm_instance
.assert_not_called()
4289 self
.vimconn
.nova
.servers
.create
.assert_not_called()
4290 mock_time
.assert_not_called()
4291 mock_update_port_security
.assert_not_called()
4292 mock_prepare_external_network
.assert_not_called()
4293 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
4294 mock_delete_vm_instance
.assert_called_once_with(None, {})
4295 mock_format_exception
.assert_called_once()
4296 arg
= mock_format_exception
.call_args
[0][0]
4297 self
.assertEqual(str(arg
), "User data could not be retrieved.")
4300 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4301 @patch.object(vimconnector
, "_reload_connection")
4302 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4303 @patch.object(vimconnector
, "_create_user_data")
4304 @patch.object(vimconnector
, "_get_vm_availability_zone")
4305 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4306 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4307 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4308 @patch.object(vimconnector
, "delete_vminstance")
4309 @patch.object(vimconnector
, "_format_exception")
4310 def test_new_vm_instance_external_network_exception(
4312 mock_format_exception
,
4313 mock_delete_vm_instance
,
4314 mock_prepare_external_network
,
4315 mock_update_port_security
,
4316 mock_prepare_disk_for_vm_instance
,
4317 mock_get_vm_availability_zone
,
4318 mock_create_user_data
,
4319 mock_prepare_network_for_vm_instance
,
4320 mock_reload_connection
,
4321 mock_remove_keep_flag_from_persistent_volumes
,
4324 """New VM instance creation, external network connection has failed as floating
4325 ip could not be created."""
4327 mock_create_user_data
.return_value
= True, "userdata"
4329 mock_get_vm_availability_zone
.return_value
= "nova"
4331 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4333 mock_time
.return_value
= time_return_value
4335 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
4337 mock_prepare_external_network
.side_effect
= VimConnException(
4338 "Can not create floating ip."
4341 self
.vimconn
.new_vminstance(
4347 affinity_group_list
,
4351 availability_zone_index
,
4352 availability_zone_list
,
4355 mock_reload_connection
.assert_called_once()
4356 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4361 external_network
=[],
4362 no_secured_ports
=[],
4364 mock_create_user_data
.assert_called_once_with(cloud_config
)
4365 mock_get_vm_availability_zone
.assert_called_once_with(
4366 availability_zone_index
, availability_zone_list
4368 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4370 existing_vim_volumes
=[],
4373 block_device_mapping
={},
4374 disk_list
=disk_list2
,
4376 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4381 security_groups
="default",
4382 availability_zone
="nova",
4383 key_name
="my_keypair",
4384 userdata
="userdata",
4386 block_device_mapping
={},
4389 mock_time
.assert_called_once()
4390 mock_update_port_security
.assert_called_once_with([], self
.server
)
4391 mock_prepare_external_network
.assert_called_once_with(
4392 external_network
=[],
4395 vm_start_time
=time_return_value
,
4397 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
4398 mock_delete_vm_instance
.assert_called_once_with(self
.server
.id, {})
4399 mock_format_exception
.assert_called_once()
4400 arg
= mock_format_exception
.call_args
[0][0]
4401 self
.assertEqual(str(arg
), "Can not create floating ip.")
4404 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4405 @patch.object(vimconnector
, "_reload_connection")
4406 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4407 @patch.object(vimconnector
, "_create_user_data")
4408 @patch.object(vimconnector
, "_get_vm_availability_zone")
4409 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4410 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4411 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4412 @patch.object(vimconnector
, "delete_vminstance")
4413 @patch.object(vimconnector
, "_format_exception")
4414 def test_new_vm_instance_with_affinity_group(
4416 mock_format_exception
,
4417 mock_delete_vm_instance
,
4418 mock_prepare_external_network
,
4419 mock_update_port_security
,
4420 mock_prepare_disk_for_vm_instance
,
4421 mock_get_vm_availability_zone
,
4422 mock_create_user_data
,
4423 mock_prepare_network_for_vm_instance
,
4424 mock_reload_connection
,
4425 mock_remove_keep_flag_from_persistent_volumes
,
4428 """New VM creation with affinity group."""
4429 affinity_group_list
= [
4430 {"affinity_group_id": "38b73-e9cc-5a6a-t270-82cc4811bd4a"}
4432 mock_create_user_data
.return_value
= True, "userdata"
4433 mock_get_vm_availability_zone
.return_value
= "nova"
4434 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4435 mock_time
.return_value
= time_return_value
4436 expected_result
= self
.server
.id, {}
4438 result
= self
.vimconn
.new_vminstance(
4444 affinity_group_list
,
4448 availability_zone_index
,
4449 availability_zone_list
,
4451 self
.assertEqual(result
, expected_result
)
4453 mock_reload_connection
.assert_called_once()
4454 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4459 external_network
=[],
4460 no_secured_ports
=[],
4462 mock_create_user_data
.assert_called_once_with(cloud_config
)
4463 mock_get_vm_availability_zone
.assert_called_once_with(
4464 availability_zone_index
, availability_zone_list
4466 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4468 existing_vim_volumes
=[],
4471 block_device_mapping
={},
4472 disk_list
=disk_list2
,
4474 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4479 security_groups
="default",
4480 availability_zone
="nova",
4481 key_name
="my_keypair",
4482 userdata
="userdata",
4484 block_device_mapping
={},
4485 scheduler_hints
={"group": "38b73-e9cc-5a6a-t270-82cc4811bd4a"},
4487 mock_time
.assert_called_once()
4488 mock_update_port_security
.assert_called_once_with([], self
.server
)
4489 mock_prepare_external_network
.assert_called_once_with(
4490 external_network
=[],
4493 vm_start_time
=time_return_value
,
4495 mock_remove_keep_flag_from_persistent_volumes
.assert_not_called()
4496 mock_delete_vm_instance
.assert_not_called()
4497 mock_format_exception
.assert_not_called()
4500 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4501 @patch.object(vimconnector
, "_reload_connection")
4502 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4503 @patch.object(vimconnector
, "_create_user_data")
4504 @patch.object(vimconnector
, "_get_vm_availability_zone")
4505 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4506 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4507 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4508 @patch.object(vimconnector
, "delete_vminstance")
4509 @patch.object(vimconnector
, "_format_exception")
4510 def test_new_vm_instance_nova_server_create_failed(
4512 mock_format_exception
,
4513 mock_delete_vm_instance
,
4514 mock_prepare_external_network
,
4515 mock_update_port_security
,
4516 mock_prepare_disk_for_vm_instance
,
4517 mock_get_vm_availability_zone
,
4518 mock_create_user_data
,
4519 mock_prepare_network_for_vm_instance
,
4520 mock_reload_connection
,
4521 mock_remove_keep_flag_from_persistent_volumes
,
4524 """New VM(server) creation failed."""
4526 mock_create_user_data
.return_value
= True, "userdata"
4528 mock_get_vm_availability_zone
.return_value
= "nova"
4530 self
.vimconn
.nova
.servers
.create
.side_effect
= Exception(
4531 "Server could not be created."
4534 mock_time
.return_value
= time_return_value
4536 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
4538 self
.vimconn
.new_vminstance(
4544 affinity_group_list
,
4548 availability_zone_index
,
4549 availability_zone_list
,
4552 mock_reload_connection
.assert_called_once()
4553 mock_prepare_network_for_vm_instance
.assert_called_once_with(
4558 external_network
=[],
4559 no_secured_ports
=[],
4561 mock_create_user_data
.assert_called_once_with(cloud_config
)
4562 mock_get_vm_availability_zone
.assert_called_once_with(
4563 availability_zone_index
, availability_zone_list
4565 mock_prepare_disk_for_vm_instance
.assert_called_once_with(
4567 existing_vim_volumes
=[],
4570 block_device_mapping
={},
4571 disk_list
=disk_list2
,
4574 self
.vimconn
.nova
.servers
.create
.assert_called_once_with(
4579 security_groups
="default",
4580 availability_zone
="nova",
4581 key_name
="my_keypair",
4582 userdata
="userdata",
4584 block_device_mapping
={},
4587 mock_time
.assert_not_called()
4588 mock_update_port_security
.assert_not_called()
4589 mock_prepare_external_network
.assert_not_called()
4590 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
4591 mock_delete_vm_instance
.assert_called_once_with(None, {})
4592 mock_format_exception
.assert_called_once()
4593 arg
= mock_format_exception
.call_args
[0][0]
4594 self
.assertEqual(str(arg
), "Server could not be created.")
4597 @patch.object(vimconnector
, "remove_keep_tag_from_persistent_volumes")
4598 @patch.object(vimconnector
, "_reload_connection")
4599 @patch.object(vimconnector
, "_prepare_network_for_vminstance")
4600 @patch.object(vimconnector
, "_create_user_data")
4601 @patch.object(vimconnector
, "_get_vm_availability_zone")
4602 @patch.object(vimconnector
, "_prepare_disk_for_vminstance")
4603 @patch.object(vimconnector
, "_update_port_security_for_vminstance")
4604 @patch.object(vimconnector
, "_prepare_external_network_for_vminstance")
4605 @patch.object(vimconnector
, "delete_vminstance")
4606 @patch.object(vimconnector
, "_format_exception")
4607 def test_new_vm_instance_connection_exception(
4609 mock_format_exception
,
4610 mock_delete_vm_instance
,
4611 mock_prepare_external_network
,
4612 mock_update_port_security
,
4613 mock_prepare_disk_for_vm_instance
,
4614 mock_get_vm_availability_zone
,
4615 mock_create_user_data
,
4616 mock_prepare_network_for_vm_instance
,
4617 mock_reload_connection
,
4618 mock_remove_keep_flag_from_persistent_volumes
,
4621 """Connection to Cloud API has failed."""
4622 mock_reload_connection
.side_effect
= Exception("Can not connect to Cloud APIs.")
4623 mock_create_user_data
.return_value
= True, "userdata"
4624 mock_get_vm_availability_zone
.return_value
= "nova"
4625 self
.vimconn
.nova
.servers
.create
.return_value
= self
.server
4626 mock_time
.return_value
= time_return_value
4627 mock_remove_keep_flag_from_persistent_volumes
.return_value
= {}
4629 self
.vimconn
.new_vminstance(
4635 affinity_group_list
,
4639 availability_zone_index
,
4640 availability_zone_list
,
4642 mock_format_exception
.assert_called_once()
4643 arg
= mock_format_exception
.call_args
[0][0]
4644 self
.assertEqual(str(arg
), "Can not connect to Cloud APIs.")
4645 mock_reload_connection
.assert_called_once()
4646 mock_prepare_network_for_vm_instance
.assert_not_called()
4647 mock_create_user_data
.assert_not_called()
4648 mock_get_vm_availability_zone
.assert_not_called()
4649 mock_prepare_disk_for_vm_instance
.assert_not_called()
4650 self
.vimconn
.nova
.servers
.create
.assert_not_called()
4651 mock_time
.assert_not_called()
4652 mock_update_port_security
.assert_not_called()
4653 mock_prepare_external_network
.assert_not_called()
4654 mock_remove_keep_flag_from_persistent_volumes
.assert_called_once_with({})
4655 mock_delete_vm_instance
.assert_called_once_with(None, {})
4657 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4658 def test_delete_vm_ports_attached_to_network_empty_created_items(
4659 self
, mock_delete_ports_by_id_wth_neutron
4661 """Created_items is emtpty."""
4663 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4664 self
.vimconn
.neutron
.list_ports
.assert_not_called()
4665 self
.vimconn
.neutron
.delete_port
.assert_not_called()
4666 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4668 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4669 def test_delete_vm_ports_attached_to_network(
4670 self
, mock_delete_ports_by_id_wth_neutron
4673 "floating_ip:308b73-t9cc-1a6a-a270-12cc4811bd4a": True,
4674 f
"volume:{volume_id2}": True,
4675 f
"volume:{volume_id}": True,
4676 f
"port:{port_id}": True,
4678 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4679 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4680 self
.vimconn
.logger
.error
.assert_not_called()
4682 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4683 def test_delete_vm_ports_attached_to_network_wthout_port(
4684 self
, mock_delete_ports_by_id_wth_neutron
4686 """Created_items does not have port."""
4688 f
"floating_ip:{floating_network_vim_id}": True,
4689 f
"volume:{volume_id2}": True,
4690 f
"volume:{volume_id}": True,
4692 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4693 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4694 self
.vimconn
.logger
.error
.assert_not_called()
4696 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4697 def test_delete_vm_ports_attached_to_network_delete_port_raise_vimconnexception(
4698 self
, mock_delete_ports_by_id_wth_neutron
4700 """_delete_ports_by_id_wth_neutron raises vimconnexception."""
4701 created_items
= deepcopy(created_items_all_true
)
4702 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
4703 "Can not delete port"
4705 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4706 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4707 self
.vimconn
.logger
.error
.assert_called_once_with(
4708 "Error deleting port: VimConnException: Can not delete port"
4711 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4712 def test_delete_vm_ports_attached_to_network_delete_port_raise_nvexception(
4713 self
, mock_delete_ports_by_id_wth_neutron
4715 """_delete_ports_by_id_wth_neutron raises nvExceptions.ClientException."""
4716 created_items
= deepcopy(created_items_all_true
)
4717 mock_delete_ports_by_id_wth_neutron
.side_effect
= nvExceptions
.ClientException(
4718 "Connection aborted."
4720 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4721 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}")
4722 self
.vimconn
.logger
.error
.assert_called_once_with(
4723 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
4726 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4727 def test_delete_vm_ports_attached_to_network_delete_port_invalid_port_item(
4728 self
, mock_delete_ports_by_id_wth_neutron
4730 """port item is invalid."""
4732 f
"floating_ip:{floating_network_vim_id}": True,
4733 f
"volume:{volume_id2}": True,
4734 f
"volume:{volume_id}": True,
4735 f
"port:{port_id}:": True,
4737 mock_delete_ports_by_id_wth_neutron
.side_effect
= VimConnException(
4738 "Port is not valid."
4740 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4741 mock_delete_ports_by_id_wth_neutron
.assert_called_once_with(f
"{port_id}:")
4742 self
.vimconn
.logger
.error
.assert_called_once_with(
4743 "Error deleting port: VimConnException: Port is not valid."
4746 @patch.object(vimconnector
, "_delete_ports_by_id_wth_neutron")
4747 def test_delete_vm_ports_attached_to_network_delete_port_already_deleted(
4748 self
, mock_delete_ports_by_id_wth_neutron
4750 """port is already deleted."""
4752 f
"floating_ip:{floating_network_vim_id}": True,
4753 f
"volume:{volume_id2}": True,
4754 f
"volume:{volume_id}": None,
4755 f
"port:{port_id}": None,
4757 self
.vimconn
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
4758 mock_delete_ports_by_id_wth_neutron
.assert_not_called()
4759 self
.vimconn
.logger
.error
.assert_not_called()
4761 def test_delete_floating_ip_by_id(self
):
4763 f
"floating_ip:{floating_network_vim_id}": True,
4764 f
"port:{port_id}": True,
4766 expected_created_items
= {
4767 f
"floating_ip:{floating_network_vim_id}": None,
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
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4773 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4774 self
.assertEqual(created_items
, expected_created_items
)
4776 def test_delete_floating_ip_by_id_floating_ip_already_deleted(self
):
4777 """floating ip is already deleted."""
4779 f
"floating_ip:{floating_network_vim_id}": None,
4780 f
"port:{port_id}": True,
4782 k_id
= floating_network_vim_id
4783 k
= f
"floating_ip:{floating_network_vim_id}"
4784 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4785 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4789 f
"floating_ip:{floating_network_vim_id}": None,
4790 f
"port:{port_id}": True,
4794 def test_delete_floating_ip_by_id_floating_ip_raises_nvexception(self
):
4795 """netron delete floating ip raises nvExceptions.ClientException."""
4797 f
"floating_ip:{floating_network_vim_id}": True,
4798 f
"port:{port_id}": True,
4800 k_id
= floating_network_vim_id
4801 k
= f
"floating_ip:{floating_network_vim_id}"
4802 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= (
4803 nvExceptions
.ClientException("Client exception occured.")
4805 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4806 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4810 f
"floating_ip:{floating_network_vim_id}": True,
4811 f
"port:{port_id}": True,
4814 self
.vimconn
.logger
.error
.assert_called_once_with(
4815 "Error deleting floating ip: ClientException: Unknown Error (HTTP Client exception occured.)"
4818 def test_delete_floating_ip_by_id_floating_ip_raises_vimconnexception(self
):
4819 """netron delete floating ip raises VimConnNotFoundException."""
4821 f
"floating_ip:{floating_network_vim_id}": True,
4822 f
"port:{port_id}": True,
4824 k_id
= floating_network_vim_id
4825 k
= f
"floating_ip:{floating_network_vim_id}"
4826 self
.vimconn
.neutron
.delete_floatingip
.side_effect
= VimConnNotFoundException(
4827 "Port id could not found."
4829 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4830 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4834 f
"floating_ip:{floating_network_vim_id}": True,
4835 f
"port:{port_id}": True,
4838 self
.vimconn
.logger
.error
.assert_called_once_with(
4839 "Error deleting floating ip: VimConnNotFoundException: Port id could not found."
4842 def test_delete_floating_ip_by_id_floating_ip_invalid_k_item(self
):
4843 """invalid floating ip item."""
4845 f
"floating_ip:{floating_network_vim_id}": True,
4846 f
"port:{port_id}": True,
4848 expected_created_items
= {
4849 f
"floating_ip:{floating_network_vim_id}::": None,
4850 f
"floating_ip:{floating_network_vim_id}": True,
4851 f
"port:{port_id}": True,
4853 k_id
= floating_network_vim_id
4854 k
= f
"floating_ip:{floating_network_vim_id}::"
4855 self
.vimconn
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
4856 self
.vimconn
.neutron
.delete_floatingip
.assert_called_once_with(k_id
)
4857 self
.assertEqual(created_items
, expected_created_items
)
4859 def test_delete_volumes_by_id_with_cinder_volume_status_available(self
):
4860 """volume status is available."""
4862 f
"floating_ip:{floating_network_vim_id}": True,
4863 f
"volume:{volume_id2}": True,
4864 f
"volume:{volume_id}": True,
4865 f
"port:{port_id}": None,
4867 expected_created_items
= {
4868 f
"floating_ip:{floating_network_vim_id}": True,
4869 f
"volume:{volume_id2}": True,
4870 f
"volume:{volume_id}": None,
4871 f
"port:{port_id}": None,
4873 volumes_to_hold
= []
4874 k
= f
"volume:{volume_id}"
4876 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4877 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4878 k
, k_id
, volumes_to_hold
, created_items
4880 self
.assertEqual(result
, None)
4881 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4882 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4883 self
.vimconn
.logger
.error
.assert_not_called()
4884 self
.assertEqual(created_items
, expected_created_items
)
4886 def test_delete_volumes_by_id_with_cinder_volume_already_deleted(self
):
4887 """volume is already deleted."""
4889 f
"floating_ip:{floating_network_vim_id}": True,
4890 f
"volume:{volume_id2}": True,
4891 f
"volume:{volume_id}": None,
4892 f
"port:{port_id}": None,
4894 expected_created_items
= {
4895 f
"floating_ip:{floating_network_vim_id}": True,
4896 f
"volume:{volume_id2}": True,
4897 f
"volume:{volume_id}": None,
4898 f
"port:{port_id}": None,
4900 volumes_to_hold
= []
4901 k
= f
"volume:{volume_id}"
4903 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4904 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4905 k
, k_id
, volumes_to_hold
, created_items
4907 self
.assertEqual(result
, None)
4908 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4909 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4910 self
.vimconn
.logger
.error
.assert_not_called()
4911 self
.assertEqual(created_items
, expected_created_items
)
4913 def test_delete_volumes_by_id_with_cinder_get_volume_raise_exception(self
):
4914 """cinder get volume raises exception."""
4916 f
"floating_ip:{floating_network_vim_id}": True,
4917 f
"volume:{volume_id2}": True,
4918 f
"volume:{volume_id}": True,
4919 f
"port:{port_id}": None,
4921 expected_created_items
= {
4922 f
"floating_ip:{floating_network_vim_id}": True,
4923 f
"volume:{volume_id2}": True,
4924 f
"volume:{volume_id}": True,
4925 f
"port:{port_id}": None,
4927 volumes_to_hold
= []
4928 k
= f
"volume:{volume_id}"
4930 self
.vimconn
.cinder
.volumes
.get
.side_effect
= Exception(
4931 "Can not get volume status."
4933 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4934 k
, k_id
, volumes_to_hold
, created_items
4936 self
.assertEqual(result
, None)
4937 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4938 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4939 self
.vimconn
.logger
.error
.assert_called_once_with(
4940 "Error deleting volume: Exception: Can not get volume status."
4942 self
.assertEqual(created_items
, expected_created_items
)
4944 def test_delete_volumes_by_id_with_cinder_delete_volume_raise_exception(self
):
4945 """cinder delete volume raises exception."""
4947 f
"floating_ip:{floating_network_vim_id}": True,
4948 f
"volume:{volume_id2}": True,
4949 f
"volume:{volume_id}": True,
4950 f
"port:{port_id}": None,
4952 expected_created_items
= {
4953 f
"floating_ip:{floating_network_vim_id}": True,
4954 f
"volume:{volume_id2}": True,
4955 f
"volume:{volume_id}": True,
4956 f
"port:{port_id}": None,
4958 volumes_to_hold
= []
4959 k
= f
"volume:{volume_id}"
4961 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "available"
4962 self
.vimconn
.cinder
.volumes
.delete
.side_effect
= nvExceptions
.ClientException(
4963 "Connection aborted."
4965 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4966 k
, k_id
, volumes_to_hold
, created_items
4968 self
.assertEqual(result
, None)
4969 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
4970 self
.vimconn
.cinder
.volumes
.delete
.assert_called_once_with(k_id
)
4971 self
.vimconn
.logger
.error
.assert_called_once_with(
4972 "Error deleting volume: ClientException: Unknown Error (HTTP Connection aborted.)"
4974 self
.assertEqual(created_items
, expected_created_items
)
4976 def test_delete_volumes_by_id_with_cinder_volume_to_be_hold(self
):
4977 """volume_to_hold has item."""
4979 f
"floating_ip:{floating_network_vim_id}": True,
4980 f
"volume:{volume_id2}": True,
4981 f
"volume:{volume_id}": True,
4982 f
"port:{port_id}": None,
4984 expected_created_items
= {
4985 f
"floating_ip:{floating_network_vim_id}": True,
4986 f
"volume:{volume_id2}": True,
4987 f
"volume:{volume_id}": True,
4988 f
"port:{port_id}": None,
4990 volumes_to_hold
= [volume_id
]
4991 k
= f
"volume:{volume_id}"
4993 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
4994 k
, k_id
, volumes_to_hold
, created_items
4996 self
.assertEqual(result
, None)
4997 self
.vimconn
.cinder
.volumes
.get
.assert_not_called()
4998 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
4999 self
.vimconn
.logger
.error
.assert_not_called()
5000 self
.assertEqual(created_items
, expected_created_items
)
5002 def test_delete_volumes_by_id_with_cinder_volume_status_not_available(self
):
5003 """volume status is not available."""
5005 f
"floating_ip:{floating_network_vim_id}": True,
5006 f
"volume:{volume_id2}": True,
5007 f
"volume:{volume_id}": True,
5008 f
"port:{port_id}": None,
5010 expected_created_items
= {
5011 f
"floating_ip:{floating_network_vim_id}": True,
5012 f
"volume:{volume_id2}": True,
5013 f
"volume:{volume_id}": True,
5014 f
"port:{port_id}": None,
5016 volumes_to_hold
= []
5017 k
= f
"volume:{volume_id}"
5019 self
.vimconn
.cinder
.volumes
.get
.return_value
.status
= "unavailable"
5020 result
= self
.vimconn
._delete
_volumes
_by
_id
_wth
_cinder
(
5021 k
, k_id
, volumes_to_hold
, created_items
5023 self
.assertEqual(result
, True)
5024 self
.vimconn
.cinder
.volumes
.get
.assert_called_once_with(k_id
)
5025 self
.vimconn
.cinder
.volumes
.delete
.assert_not_called()
5026 self
.vimconn
.logger
.error
.assert_not_called()
5027 self
.assertEqual(created_items
, expected_created_items
)
5029 def test_delete_ports_by_id_by_neutron(self
):
5030 """neutron delete ports."""
5032 self
.vimconn
.neutron
.list_ports
.return_value
= {
5033 "ports": [{"id": port_id
}, {"id": port2_id
}]
5036 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
5037 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5038 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
5039 self
.vimconn
.logger
.error
.assert_not_called()
5041 def test_delete_ports_by_id_by_neutron_id_not_in_port_list(self
):
5042 """port id not in the port list."""
5044 self
.vimconn
.neutron
.list_ports
.return_value
= {
5045 "ports": [{"id": port_id
}, {"id": port2_id
}]
5048 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
5049 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5050 self
.vimconn
.neutron
.delete_port
.assert_not_called()
5051 self
.vimconn
.logger
.error
.assert_not_called()
5053 def test_delete_ports_by_id_by_neutron_list_port_raise_exception(self
):
5054 """neutron list port raises exception."""
5056 self
.vimconn
.neutron
.list_ports
.side_effect
= nvExceptions
.ClientException(
5057 "Connection aborted."
5059 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
5060 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5061 self
.vimconn
.neutron
.delete_port
.assert_not_called()
5062 self
.vimconn
.logger
.error
.assert_called_once_with(
5063 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
5066 def test_delete_ports_by_id_by_neutron_delete_port_raise_exception(self
):
5067 """neutron delete port raises exception."""
5069 self
.vimconn
.neutron
.list_ports
.return_value
= {
5070 "ports": [{"id": port_id
}, {"id": port2_id
}]
5072 self
.vimconn
.neutron
.delete_port
.side_effect
= nvExceptions
.ClientException(
5073 "Connection aborted."
5075 self
.vimconn
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
5076 self
.vimconn
.neutron
.list_ports
.assert_called_once()
5077 self
.vimconn
.neutron
.delete_port
.assert_called_once_with(k_id
)
5078 self
.vimconn
.logger
.error
.assert_called_once_with(
5079 "Error deleting port: ClientException: Unknown Error (HTTP Connection aborted.)"
5082 def test_get_item_name_id(self
):
5083 """Get name and id successfully."""
5084 k
= f
"some:{port_id}"
5085 result
= self
.vimconn
._get
_item
_name
_id
(k
)
5086 self
.assertEqual(result
, ("some", f
"{port_id}"))
5088 def test_get_item_name_id_wthout_semicolon(self
):
5089 """Does not have seperator."""
5090 k
= f
"some{port_id}"
5091 result
= self
.vimconn
._get
_item
_name
_id
(k
)
5092 self
.assertEqual(result
, (f
"some{port_id}", ""))
5094 def test_get_item_name_id_empty_string(self
):
5097 result
= self
.vimconn
._get
_item
_name
_id
(k
)
5098 self
.assertEqual(result
, ("", ""))
5100 def test_get_item_name_id_k_is_none(self
):
5103 with self
.assertRaises(AttributeError):
5104 self
.vimconn
._get
_item
_name
_id
(k
)
5106 @patch.object(vimconnector
, "_get_item_name_id")
5107 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5108 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5109 def test_delete_created_items(
5111 mock_delete_floating_ip_by_id
,
5112 mock_delete_volumes_by_id_wth_cinder
,
5113 mock_get_item_name_id
,
5115 """Created items has floating ip and volume."""
5117 f
"floating_ip:{floating_network_vim_id}": True,
5118 f
"volume:{volume_id}": True,
5119 f
"port:{port_id}": None,
5121 mock_get_item_name_id
.side_effect
= [
5122 ("floating_ip", f
"{floating_network_vim_id}"),
5123 ("volume", f
"{volume_id}"),
5125 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
5126 volumes_to_hold
= []
5127 keep_waiting
= False
5128 result
= self
.vimconn
._delete
_created
_items
(
5129 created_items
, volumes_to_hold
, keep_waiting
5131 self
.assertEqual(result
, True)
5132 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5133 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5134 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5136 mock_delete_floating_ip_by_id
.assert_called_once_with(
5137 f
"floating_ip:{floating_network_vim_id}",
5138 f
"{floating_network_vim_id}",
5141 self
.vimconn
.logger
.error
.assert_not_called()
5143 @patch.object(vimconnector
, "_get_item_name_id")
5144 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5145 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5146 def test_delete_created_items_wth_volumes_to_hold(
5148 mock_delete_floating_ip_by_id
,
5149 mock_delete_volumes_by_id_wth_cinder
,
5150 mock_get_item_name_id
,
5152 """Created items has floating ip and volume and volumes_to_hold has items."""
5154 f
"floating_ip:{floating_network_vim_id}": True,
5155 f
"volume:{volume_id}": True,
5156 f
"port:{port_id}": None,
5158 mock_get_item_name_id
.side_effect
= [
5159 ("floating_ip", f
"{floating_network_vim_id}"),
5160 ("volume", f
"{volume_id}"),
5162 mock_delete_volumes_by_id_wth_cinder
.return_value
= True
5163 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5164 keep_waiting
= False
5165 result
= self
.vimconn
._delete
_created
_items
(
5166 created_items
, volumes_to_hold
, keep_waiting
5168 self
.assertEqual(result
, True)
5169 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5170 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5171 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
5173 mock_delete_floating_ip_by_id
.assert_called_once_with(
5174 f
"floating_ip:{floating_network_vim_id}",
5175 f
"{floating_network_vim_id}",
5178 self
.vimconn
.logger
.error
.assert_not_called()
5180 @patch.object(vimconnector
, "_get_item_name_id")
5181 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5182 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5183 def test_delete_created_items_wth_keep_waiting_true(
5185 mock_delete_floating_ip_by_id
,
5186 mock_delete_volumes_by_id_wth_cinder
,
5187 mock_get_item_name_id
,
5189 """Keep waiting initial value is True."""
5191 f
"floating_ip:{floating_network_vim_id}": True,
5192 f
"volume:{volume_id}": True,
5193 f
"port:{port_id}": None,
5195 mock_get_item_name_id
.side_effect
= [
5196 ("floating_ip", f
"{floating_network_vim_id}"),
5197 ("volume", f
"{volume_id}"),
5199 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5200 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5202 result
= self
.vimconn
._delete
_created
_items
(
5203 created_items
, volumes_to_hold
, keep_waiting
5205 self
.assertEqual(result
, True)
5206 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5207 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5208 f
"volume:{volume_id}", f
"{volume_id}", volumes_to_hold
, created_items
5210 mock_delete_floating_ip_by_id
.assert_called_once_with(
5211 f
"floating_ip:{floating_network_vim_id}",
5212 f
"{floating_network_vim_id}",
5215 self
.vimconn
.logger
.error
.assert_not_called()
5217 @patch.object(vimconnector
, "_get_item_name_id")
5218 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5219 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5220 def test_delete_created_items_delete_vol_raises(
5222 mock_delete_floating_ip_by_id
,
5223 mock_delete_volumes_by_id_wth_cinder
,
5224 mock_get_item_name_id
,
5226 """Delete volume raises exception."""
5228 f
"floating_ip:{floating_network_vim_id}": True,
5229 f
"volume:{volume_id}": True,
5230 f
"port:{port_id}": None,
5232 mock_get_item_name_id
.side_effect
= [
5233 ("floating_ip", f
"{floating_network_vim_id}"),
5234 ("volume", f
"{volume_id}"),
5236 mock_delete_volumes_by_id_wth_cinder
.side_effect
= ConnectionError(
5237 "Connection failed."
5239 volumes_to_hold
= []
5240 keep_waiting
= False
5241 result
= self
.vimconn
._delete
_created
_items
(
5242 created_items
, volumes_to_hold
, keep_waiting
5244 self
.assertEqual(result
, False)
5245 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5246 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5247 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5249 mock_delete_floating_ip_by_id
.assert_called_once_with(
5250 f
"floating_ip:{floating_network_vim_id}",
5251 f
"{floating_network_vim_id}",
5254 self
.vimconn
.logger
.error
.assert_called_once_with(
5255 "Error deleting volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a: Connection failed."
5258 @patch.object(vimconnector
, "_get_item_name_id")
5259 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5260 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5261 def test_delete_created_items_delete_fip_raises(
5263 mock_delete_floating_ip_by_id
,
5264 mock_delete_volumes_by_id_wth_cinder
,
5265 mock_get_item_name_id
,
5267 """Delete floating ip raises exception."""
5269 f
"floating_ip:{floating_network_vim_id}": True,
5270 f
"volume:{volume_id}": True,
5271 f
"port:{port_id}": None,
5273 mock_get_item_name_id
.side_effect
= [
5274 ("floating_ip", f
"{floating_network_vim_id}"),
5275 ("volume", f
"{volume_id}"),
5277 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
5278 mock_delete_floating_ip_by_id
.side_effect
= ConnectionError(
5279 "Connection failed."
5281 volumes_to_hold
= []
5283 result
= self
.vimconn
._delete
_created
_items
(
5284 created_items
, volumes_to_hold
, keep_waiting
5286 self
.assertEqual(result
, True)
5287 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5288 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5289 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5291 mock_delete_floating_ip_by_id
.assert_called_once_with(
5292 f
"floating_ip:{floating_network_vim_id}",
5293 f
"{floating_network_vim_id}",
5296 self
.vimconn
.logger
.error
.assert_called_once_with(
5297 "Error deleting floating_ip:108b73-e9cc-5a6a-t270-82cc4811bd4a: Connection failed."
5300 @patch.object(vimconnector
, "_get_item_name_id")
5301 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5302 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5303 def test_delete_created_items_get_item_name_raises(
5305 mock_delete_floating_ip_by_id
,
5306 mock_delete_volumes_by_id_wth_cinder
,
5307 mock_get_item_name_id
,
5309 """Get item, name raises exception."""
5312 f
"volume{volume_id}": True,
5313 f
"port:{port_id}": None,
5315 mock_get_item_name_id
.side_effect
= [
5316 TypeError("Invalid Type"),
5317 AttributeError("Invalid attribute"),
5319 volumes_to_hold
= []
5320 keep_waiting
= False
5321 result
= self
.vimconn
._delete
_created
_items
(
5322 created_items
, volumes_to_hold
, keep_waiting
5324 self
.assertEqual(result
, False)
5325 self
.assertEqual(mock_get_item_name_id
.call_count
, 2)
5326 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5327 mock_delete_floating_ip_by_id
.assert_not_called()
5328 _call_logger
= self
.vimconn
.logger
.error
.call_args_list
5329 self
.assertEqual(_call_logger
[0][0], ("Error deleting 3: Invalid Type",))
5332 (f
"Error deleting volume{volume_id}: Invalid attribute",),
5335 @patch.object(vimconnector
, "_get_item_name_id")
5336 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5337 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5338 def test_delete_created_items_no_fip_wth_port(
5340 mock_delete_floating_ip_by_id
,
5341 mock_delete_volumes_by_id_wth_cinder
,
5342 mock_get_item_name_id
,
5344 """Created items has port, does not have floating ip."""
5346 f
"volume:{volume_id}": True,
5347 f
"port:{port_id}": True,
5349 mock_get_item_name_id
.side_effect
= [
5350 ("volume", f
"{volume_id}"),
5351 ("port", f
"{port_id}"),
5353 mock_delete_volumes_by_id_wth_cinder
.return_value
= False
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
, 2)
5361 mock_delete_volumes_by_id_wth_cinder
.assert_called_once_with(
5362 f
"volume:{volume_id}", f
"{volume_id}", [], created_items
5364 mock_delete_floating_ip_by_id
.assert_not_called()
5365 self
.vimconn
.logger
.error
.assert_not_called()
5367 @patch.object(vimconnector
, "_get_item_name_id")
5368 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5369 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5370 def test_delete_created_items_no_volume(
5372 mock_delete_floating_ip_by_id
,
5373 mock_delete_volumes_by_id_wth_cinder
,
5374 mock_get_item_name_id
,
5376 """Created items does not have volume."""
5378 f
"floating_ip:{floating_network_vim_id}": True,
5379 f
"port:{port_id}": None,
5381 mock_get_item_name_id
.side_effect
= [
5382 ("floating_ip", f
"{floating_network_vim_id}")
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 self
.assertEqual(mock_get_item_name_id
.call_count
, 1)
5391 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5392 mock_delete_floating_ip_by_id
.assert_called_once_with(
5393 f
"floating_ip:{floating_network_vim_id}",
5394 f
"{floating_network_vim_id}",
5397 self
.vimconn
.logger
.error
.assert_not_called()
5399 @patch.object(vimconnector
, "_get_item_name_id")
5400 @patch.object(vimconnector
, "_delete_volumes_by_id_wth_cinder")
5401 @patch.object(vimconnector
, "_delete_floating_ip_by_id")
5402 def test_delete_created_items_already_deleted(
5404 mock_delete_floating_ip_by_id
,
5405 mock_delete_volumes_by_id_wth_cinder
,
5406 mock_get_item_name_id
,
5408 """All created items are alerady deleted."""
5410 f
"floating_ip:{floating_network_vim_id}": None,
5411 f
"volume:{volume_id}": None,
5412 f
"port:{port_id}": None,
5414 volumes_to_hold
= []
5415 keep_waiting
= False
5416 result
= self
.vimconn
._delete
_created
_items
(
5417 created_items
, volumes_to_hold
, keep_waiting
5419 self
.assertEqual(result
, False)
5420 mock_get_item_name_id
.assert_not_called()
5421 mock_delete_volumes_by_id_wth_cinder
.assert_not_called()
5422 mock_delete_floating_ip_by_id
.assert_not_called()
5423 self
.vimconn
.logger
.error
.assert_not_called()
5425 @patch("time.sleep")
5426 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5427 @patch.object(vimconnector
, "_format_exception")
5428 @patch.object(vimconnector
, "_reload_connection")
5429 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5430 @patch.object(vimconnector
, "_delete_created_items")
5431 def test_delete_vminstance_successfully(
5433 mock_delete_created_items
,
5434 mock_delete_vm_ports_attached_to_network
,
5435 mock_reload_connection
,
5436 mock_format_exception
,
5437 mock_extract_items_wth_keep_flag_from_created_items
,
5440 vm_id
= f
"{virtual_mac_id}"
5441 created_items
= deepcopy(created_items_all_true
)
5442 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5443 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5444 mock_delete_created_items
.return_value
= False
5445 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5446 mock_reload_connection
.assert_called_once()
5447 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5448 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5449 mock_delete_created_items
.assert_called_once_with(
5450 created_items
, volumes_to_hold
, False
5452 mock_sleep
.assert_not_called()
5453 mock_format_exception
.assert_not_called()
5454 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5458 @patch("time.sleep")
5459 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5460 @patch.object(vimconnector
, "_format_exception")
5461 @patch.object(vimconnector
, "_reload_connection")
5462 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5463 @patch.object(vimconnector
, "_delete_created_items")
5464 def test_delete_vminstance_created_items_has_keep_flag(
5466 mock_delete_created_items
,
5467 mock_delete_vm_ports_attached_to_network
,
5468 mock_reload_connection
,
5469 mock_format_exception
,
5470 mock_extract_items_wth_keep_flag_from_created_items
,
5473 """Created_items includes items which has keep flag."""
5474 vm_id
= f
"{virtual_mac_id}"
5475 initial_created_items
= {
5476 f
"port{port_id}": True,
5477 f
"floating_ip{floating_network_vim_id}": None,
5478 f
"volume{volume_id}keep": True,
5479 f
"volume{volume_id2}keep": True,
5482 f
"port{port_id}": True,
5483 f
"floating_ip{floating_network_vim_id}": None,
5485 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5486 volumes_to_hold
= []
5487 mock_delete_created_items
.return_value
= False
5488 self
.vimconn
.delete_vminstance(vm_id
, initial_created_items
, volumes_to_hold
)
5489 mock_reload_connection
.assert_called_once()
5490 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5491 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5492 mock_delete_created_items
.assert_called_once_with(
5493 created_items
, volumes_to_hold
, False
5495 mock_sleep
.assert_not_called()
5496 mock_format_exception
.assert_not_called()
5497 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5498 initial_created_items
5501 @patch("time.sleep")
5502 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5503 @patch.object(vimconnector
, "_format_exception")
5504 @patch.object(vimconnector
, "_reload_connection")
5505 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5506 @patch.object(vimconnector
, "_delete_created_items")
5507 def test_delete_vminstance_extract_items_wth_keep_raises(
5509 mock_delete_created_items
,
5510 mock_delete_vm_ports_attached_to_network
,
5511 mock_reload_connection
,
5512 mock_format_exception
,
5513 mock_extract_items_wth_keep_flag_from_created_items
,
5516 """extract_items_wth_keep_flag_from_created_items raises AttributeError."""
5517 vm_id
= f
"{virtual_mac_id}"
5518 initial_created_items
= {
5519 f
"port{port_id}": True,
5520 f
"floating_ip{floating_network_vim_id}": None,
5521 f
"volume{volume_id}keep": True,
5522 f
"volume{volume_id2}keep": True,
5525 mock_extract_items_wth_keep_flag_from_created_items
.side_effect
= AttributeError
5526 volumes_to_hold
= []
5527 mock_delete_created_items
.return_value
= False
5528 with self
.assertRaises(AttributeError):
5529 self
.vimconn
.delete_vminstance(
5530 vm_id
, initial_created_items
, volumes_to_hold
5532 mock_reload_connection
.assert_not_called()
5533 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5534 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5535 mock_delete_created_items
.assert_not_called()
5536 mock_sleep
.assert_not_called()
5537 mock_format_exception
.assert_not_called()
5538 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5539 initial_created_items
5542 @patch("time.sleep")
5543 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5544 @patch.object(vimconnector
, "_format_exception")
5545 @patch.object(vimconnector
, "_reload_connection")
5546 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5547 @patch.object(vimconnector
, "_delete_created_items")
5548 def test_delete_vminstance_delete_created_items_raises(
5550 mock_delete_created_items
,
5551 mock_delete_vm_ports_attached_to_network
,
5552 mock_reload_connection
,
5553 mock_format_exception
,
5554 mock_extract_items_wth_keep_flag_from_created_items
,
5557 """Delete creted items raises exception."""
5558 vm_id
= f
"{virtual_mac_id}"
5559 created_items
= deepcopy(created_items_all_true
)
5560 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5561 mock_sleep
= MagicMock()
5562 volumes_to_hold
= []
5563 err
= ConnectionError("ClientException occured.")
5564 mock_delete_created_items
.side_effect
= err
5565 with self
.assertRaises(ConnectionError
) as err
:
5566 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5567 self
.assertEqual(str(err
), "ClientException occured.")
5568 mock_reload_connection
.assert_called_once()
5569 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5570 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5571 mock_delete_created_items
.assert_called_once()
5572 mock_sleep
.assert_not_called()
5573 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5577 @patch("time.sleep")
5578 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5579 @patch.object(vimconnector
, "_format_exception")
5580 @patch.object(vimconnector
, "_reload_connection")
5581 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5582 @patch.object(vimconnector
, "_delete_created_items")
5583 def test_delete_vminstance_delete_vm_ports_raises(
5585 mock_delete_created_items
,
5586 mock_delete_vm_ports_attached_to_network
,
5587 mock_reload_connection
,
5588 mock_format_exception
,
5589 mock_extract_items_wth_keep_flag_from_created_items
,
5592 """Delete vm ports raises exception."""
5593 vm_id
= f
"{virtual_mac_id}"
5594 created_items
= deepcopy(created_items_all_true
)
5595 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5596 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5597 err
= ConnectionError("ClientException occured.")
5598 mock_delete_vm_ports_attached_to_network
.side_effect
= err
5599 mock_delete_created_items
.side_effect
= err
5600 with self
.assertRaises(ConnectionError
) as err
:
5601 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5602 self
.assertEqual(str(err
), "ClientException occured.")
5603 mock_reload_connection
.assert_called_once()
5604 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5605 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5606 mock_delete_created_items
.assert_not_called()
5607 mock_sleep
.assert_not_called()
5608 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5612 @patch("time.sleep")
5613 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5614 @patch.object(vimconnector
, "_format_exception")
5615 @patch.object(vimconnector
, "_reload_connection")
5616 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5617 @patch.object(vimconnector
, "_delete_created_items")
5618 def test_delete_vminstance_nova_server_delete_raises(
5620 mock_delete_created_items
,
5621 mock_delete_vm_ports_attached_to_network
,
5622 mock_reload_connection
,
5623 mock_format_exception
,
5624 mock_extract_items_wth_keep_flag_from_created_items
,
5627 """Nova server delete raises exception."""
5628 vm_id
= f
"{virtual_mac_id}"
5629 created_items
= deepcopy(created_items_all_true
)
5630 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5631 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5632 err
= VimConnConnectionException("ClientException occured.")
5633 self
.vimconn
.nova
.servers
.delete
.side_effect
= err
5634 mock_delete_created_items
.side_effect
= err
5635 with self
.assertRaises(VimConnConnectionException
) as err
:
5636 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5637 self
.assertEqual(str(err
), "ClientException occured.")
5638 mock_reload_connection
.assert_called_once()
5639 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5640 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5641 mock_delete_created_items
.assert_not_called()
5642 mock_sleep
.assert_not_called()
5643 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5647 @patch("time.sleep")
5648 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5649 @patch.object(vimconnector
, "_format_exception")
5650 @patch.object(vimconnector
, "_reload_connection")
5651 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5652 @patch.object(vimconnector
, "_delete_created_items")
5653 def test_delete_vminstance_reload_connection_raises(
5655 mock_delete_created_items
,
5656 mock_delete_vm_ports_attached_to_network
,
5657 mock_reload_connection
,
5658 mock_format_exception
,
5659 mock_extract_items_wth_keep_flag_from_created_items
,
5662 """Reload connection raises exception."""
5663 vm_id
= f
"{virtual_mac_id}"
5664 created_items
= deepcopy(created_items_all_true
)
5665 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5666 mock_sleep
= MagicMock()
5667 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5668 err
= ConnectionError("ClientException occured.")
5669 mock_delete_created_items
.return_value
= False
5670 mock_reload_connection
.side_effect
= err
5671 with self
.assertRaises(ConnectionError
) as err
:
5672 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5673 self
.assertEqual(str(err
), "ClientException occured.")
5674 mock_reload_connection
.assert_called_once()
5675 mock_delete_vm_ports_attached_to_network
.assert_not_called()
5676 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5677 mock_delete_created_items
.assert_not_called()
5678 mock_sleep
.assert_not_called()
5679 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_created_item_vol_to_hold_are_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 """created_items and volumes_to_hold are None."""
5699 vm_id
= f
"{virtual_mac_id}"
5700 created_items
= None
5701 volumes_to_hold
= None
5702 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= {}
5703 mock_delete_created_items
.return_value
= 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_not_called()
5707 self
.vimconn
.nova
.servers
.delete
.assert_called_once_with(vm_id
)
5708 mock_delete_created_items
.assert_called_once_with({}, [], False)
5709 mock_sleep
.assert_not_called()
5710 mock_format_exception
.assert_not_called()
5711 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with({})
5713 @patch("time.sleep")
5714 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5715 @patch.object(vimconnector
, "_format_exception")
5716 @patch.object(vimconnector
, "_reload_connection")
5717 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5718 @patch.object(vimconnector
, "_delete_created_items")
5719 def test_delete_vminstance_vm_id_is_none(
5721 mock_delete_created_items
,
5722 mock_delete_vm_ports_attached_to_network
,
5723 mock_reload_connection
,
5724 mock_format_exception
,
5725 mock_extract_items_wth_keep_flag_from_created_items
,
5728 """vm_id is None."""
5730 created_items
= deepcopy(created_items_all_true
)
5731 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5732 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5733 mock_delete_created_items
.side_effect
= [True, True, False]
5734 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5735 mock_reload_connection
.assert_called_once()
5736 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5737 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5738 self
.assertEqual(mock_delete_created_items
.call_count
, 3)
5739 self
.assertEqual(mock_sleep
.call_count
, 2)
5740 mock_format_exception
.assert_not_called()
5741 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5745 @patch("time.sleep")
5746 @patch.object(vimconnector
, "_extract_items_wth_keep_flag_from_created_items")
5747 @patch.object(vimconnector
, "_format_exception")
5748 @patch.object(vimconnector
, "_reload_connection")
5749 @patch.object(vimconnector
, "_delete_vm_ports_attached_to_network")
5750 @patch.object(vimconnector
, "_delete_created_items")
5751 def test_delete_vminstance_delete_created_items_return_true(
5753 mock_delete_created_items
,
5754 mock_delete_vm_ports_attached_to_network
,
5755 mock_reload_connection
,
5756 mock_format_exception
,
5757 mock_extract_items_wth_keep_flag_from_created_items
,
5760 """Delete created items always return True."""
5762 created_items
= deepcopy(created_items_all_true
)
5763 mock_extract_items_wth_keep_flag_from_created_items
.return_value
= created_items
5764 volumes_to_hold
= [f
"{volume_id}", f
"{volume_id2}"]
5765 mock_delete_created_items
.side_effect
= [True] * 1800
5766 self
.vimconn
.delete_vminstance(vm_id
, created_items
, volumes_to_hold
)
5767 mock_reload_connection
.assert_called_once()
5768 mock_delete_vm_ports_attached_to_network
.assert_called_once_with(created_items
)
5769 self
.vimconn
.nova
.servers
.delete
.assert_not_called()
5770 self
.assertEqual(mock_delete_created_items
.call_count
, 1800)
5771 self
.assertEqual(mock_sleep
.call_count
, 1800)
5772 mock_format_exception
.assert_not_called()
5773 mock_extract_items_wth_keep_flag_from_created_items
.assert_called_once_with(
5777 def test_remove_keep_tag_from_persistent_volumes_keep_flag_exists(self
):
5778 """Keep flag exists in created items."""
5780 f
"port:{port_id}": True,
5781 f
"floating_ip:{floating_network_vim_id}": True,
5782 f
"volume:{volume_id}:keep": True,
5783 f
"volume:{volume_id2}:keep": True,
5786 f
"port:{port_id}": True,
5787 f
"floating_ip:{floating_network_vim_id}": True,
5788 f
"volume:{volume_id}": True,
5789 f
"volume:{volume_id2}": True,
5791 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
5792 self
.assertDictEqual(result
, expected_result
)
5794 def test_remove_keep_tag_from_persistent_volumes_without_keep_flag(self
):
5795 """Keep flag does not exist in created items."""
5797 f
"port:{port_id}": True,
5798 f
"floating_ip:{floating_network_vim_id}": True,
5799 f
"volume:{volume_id}": True,
5800 f
"volume:{volume_id2}": True,
5802 result
= self
.vimconn
.remove_keep_tag_from_persistent_volumes(created_items
)
5803 self
.assertDictEqual(result
, created_items
)
5805 def test_update_block_device_mapping_empty_volume(self
):
5808 block_device_mapping
= {}
5809 base_disk_index
= 100
5812 with self
.assertRaises(VimConnException
) as err
:
5813 self
.vimconn
.update_block_device_mapping(
5814 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
5816 self
.assertEqual(str(err
), "Volume is empty.")
5817 self
.assertEqual(block_device_mapping
, {})
5818 self
.assertEqual(created_items
, {})
5820 def test_update_block_device_mapping_invalid_volume(self
):
5823 block_device_mapping
= {}
5824 base_disk_index
= 100
5827 with self
.assertRaises(VimConnException
) as err
:
5828 self
.vimconn
.update_block_device_mapping(
5829 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
5832 str(err
), "Created volume is not valid, does not have id attribute."
5834 self
.assertEqual(block_device_mapping
, {})
5835 self
.assertEqual(created_items
, {})
5837 def test_update_block_device_mapping(self
):
5839 volume
= MagicMock(autospec
=True)
5840 volume
.id = volume_id
5841 block_device_mapping
= {}
5842 base_disk_index
= 100
5845 self
.vimconn
.update_block_device_mapping(
5846 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
5849 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
5852 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a": True}
5855 def test_update_block_device_mapping_with_keep_flag(self
):
5857 volume
= MagicMock(autospec
=True)
5858 volume
.id = volume_id
5859 block_device_mapping
= {}
5860 base_disk_index
= 100
5861 disk
= {"size": 10, "keep": True}
5863 self
.vimconn
.update_block_device_mapping(
5864 volume
, block_device_mapping
, base_disk_index
, disk
, created_items
5867 block_device_mapping
, {"vdd": "ac408b73-b9cc-4a6a-a270-82cc4811bd4a"}
5870 created_items
, {"volume:ac408b73-b9cc-4a6a-a270-82cc4811bd4a:keep": True}
5873 def test_extract_items_with_keep_flag_item_has_keep_flag(self
):
5874 created_items
= deepcopy(created_items_all_true
)
5875 created_items
[f
"volume:{volume_id2}:keep"] = True
5876 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5879 self
.assertEqual(result
, deepcopy(created_items_all_true
))
5881 def test_extract_items_with_keep_flag_no_item_wth_keep_flag(self
):
5882 created_items
= deepcopy(created_items_all_true
)
5883 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5886 self
.assertEqual(result
, deepcopy(created_items_all_true
))
5888 def test_extract_items_with_keep_flag_all_items_are_already_deleted(self
):
5890 f
"port:{port_id}": None,
5891 f
"floating_ip:{floating_network_vim_id}": None,
5892 f
"volume:{volume_id}:keep": None,
5893 f
"volume:{volume_id2}:keep": None,
5896 f
"port:{port_id}": None,
5897 f
"floating_ip:{floating_network_vim_id}": None,
5899 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5902 self
.assertEqual(result
, expected_result
)
5904 def test_extract_items_with_keep_flag_without_semicolon(self
):
5906 f
"port{port_id}": True,
5907 f
"floating_ip{floating_network_vim_id}": None,
5908 f
"volume{volume_id}keep": True,
5909 f
"volume{volume_id2}keep": True,
5911 result
= self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
5914 self
.assertEqual(result
, {})
5916 def test_extract_items_with_keep_flag_invalid_type_created_items(self
):
5917 created_items
= [{f
"port{port_id}": True}, {f
"volume{volume_id2}keep": True}]
5918 with self
.assertRaises(AttributeError):
5919 self
.vimconn
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(created_items
)
5922 if __name__
== "__main__":